Open Chrome and go to my Google Business Profile at [YOUR_GBP_URL] and these competitors: [C1_URL], [C2_URL], [C3_URL].

For each listing, extract every visible attribute: category, secondary categories, service list, service descriptions, opening hours, holiday hours, business description, attributes (women-owned, wheelchair accessible, etc.), Q&A count, review count, review score, photo count, post frequency, product listings, appointment link, menu link.

Return a 5-column table: attribute | my business | comp 1 | comp 2 | comp 3.

At the bottom, list every attribute at least 2 of 3 competitors have that I don't. Rank the gap list by likely 3-Pack ranking impact.

For the query "[TARGET_KEYWORD] in [CITY]", the current Google 3-Pack shows [COMP1], [COMP2], [COMP3].

Go to each of their websites and list every URL under /services, /locations, /areas-served, /faq, or equivalent. Also list any city-specific landing pages, neighborhood pages, or service+city combination pages.

Return a table with: competitor | URL | page type | word count (approximate) | primary topic | secondary topics.

At the end, produce two lists:
1. Page templates at least 2 of 3 competitors have that I don't at [MY_DOMAIN].
2. Topics/services they cover in dedicated pages that I only mention in passing.

Rank list 1 by likelihood to move Local Pack ranking based on how directly it addresses the target query.

My correct business info is:
Name: [EXACT_LEGAL_NAME]
Address: [EXACT_ADDRESS]
Phone: [EXACT_PHONE]
Website: [EXACT_URL]

Search the web for every citation of my business. Include Yelp, BBB, Yellow Pages, Angi, Thumbtack, Nextdoor, MapQuest, Bing Places, Apple Maps, industry-specific directories, and any listing that references my business name.

For each citation return: source | listed name | listed address | listed phone | listed URL | match status (exact / minor drift / major drift / defunct listing to suppress).

Prioritize the "major drift" and "defunct" rows by directory authority. Give me the top 10 to fix this week.

Here are the last [N] reviews of my business at [YOUR_GBP_URL], scraped and pasted below:

[PASTE_REVIEWS_HERE]

Do three passes over this text:

Pass 1: Verbatim phrase extraction. List the top 30 exact phrases customers used to describe (a) what job they hired us for, (b) what pain we solved, (c) what specifically pleased or surprised them, (d) any objection they mentioned overcoming.

Pass 2: Content angle generation. For each of the top 15 phrases from pass 1, propose a specific FAQ page title that would rank for that phrase as a long-tail query.

Pass 3: Priority ranking. Rank the 15 FAQ ideas by (a) how often the phrase appears, (b) how commercially valuable the underlying intent is, (c) how likely a page is to earn an AI Overview citation for that phrase.

Attached below is a CSV export from my GeoGrid rank tracker. Columns: latitude, longitude, keyword, my_rank, top_competitor, distance_from_my_gbp_meters.

[PASTE_CSV_HERE]

Do this analysis:

1. Cluster the grid points into zones by proximity (within 500m of each other = one zone).
2. For each zone, compute average rank, worst rank, competitor variety, and estimated population density.
3. Flag zones where my_rank > 5 AND distance_from_my_gbp_meters < 2000. These are the "should be winning but not" zones.
4. Rank the flagged zones by likely commercial value (population × how close to my GBP).
5. For the top 5, propose a specific weekly-post schedule, citation-fix list, and any structural GBP change (service area boundary edit, category addition) that could move ranking in that zone specifically.

Attached is a Search Console export for the last 90 days: query | page | impressions | clicks | CTR | position.

[PASTE_GSC_EXPORT_HERE]

Filter to rows where position is between 11 and 20 AND impressions > 100.

For each page 2 keyword: open the page on my site that's ranking for it. Tell me whether the keyword is in the title tag, whether it's in the H1, whether it's in the first 100 words, how long the page is, whether the page has internal links pointing to it, and what the current meta description says.

Build a 30-day optimization sprint:
Week 1: title tag + H1 fixes for the top 10 page 2 keywords
Week 2: content additions for pages under 500 words
Week 3: internal linking fixes (exactly which pages should link to which pages with which anchor text)
Week 4: meta description rewrites for pages with high impressions but low CTR

For every fix, give me the exact new copy to paste. Don't give me instructions. Give me the actual title tag, H1, and meta description to use.

For the query "[TARGET_QUERY]", the current AI Overview (Google) cites [CITED_URL_1] and [CITED_URL_2]. ChatGPT cites [CHATGPT_CITED_URL]. Perplexity cites [PPX_CITED_URL_1] and [PPX_CITED_URL_2].

Fetch each cited page. For each, extract:
- H1 and H2 structure
- Whether the answer to the query appears in the first 100 words
- Presence of answer-block formats: definition, numbered list, comparison table, FAQ
- Named entity density (per 200 words)
- Presence of freshness signals (dates, "updated on")
- Presence of source attribution (external references, expert quotes)
- Schema present (Article, HowTo, FAQPage, etc.)

Now fetch my page at [MY_URL] and do the same extraction.

Return a diff table: signal | AI Overview citations (avg) | my page | gap.

For every gap, give me the exact copy or structural change to close it. Don't describe. Write the copy.

Here is a section of a blog post:

[PASTE_SECTION]

Rewrite it into extractable answer-block format:

1. Lead with a 40 to 60 word definition or direct answer to the section's implied question, in the first paragraph.
2. Follow with a 3 to 6 item bulleted list of the key points.
3. If the section compares options, add a 3-column comparison table.
4. If the section answers a common question, add a Q&A pair labeled "Q:" and "A:".
5. Preserve the original examples, quotes, and voice.
6. Do not shorten by more than 15%. Do not remove any factual claim.

Output the rewritten section only, ready to paste in.

My page at [MY_URL] targets the topic "[MAIN_TOPIC]".

Do a two-part audit:

Part 1: Entity extraction from my page. List every named entity currently on the page (people, places, tools, concepts, brands, methodologies). Group by type.

Part 2: Entity gap analysis. Based on what a topic-model would associate with "[MAIN_TOPIC]", list 30 entities I should mention that I don't. For each, categorize:
- Must-have (core to the topic)
- Should-have (adds depth)
- Nice-to-have (adds freshness)

For every "must-have" and "should-have", suggest a specific paragraph in my current page where the entity could be injected naturally, and write the 1 to 2 sentence injection.

For these 5 target queries relevant to my niche [NICHE]:
1. [QUERY_1]
2. [QUERY_2]
3. [QUERY_3]
4. [QUERY_4]
5. [QUERY_5]

Below I've pasted each query and the answer returned by ChatGPT, Claude, Perplexity, and Gemini. For each answer I've indicated which URLs were cited.

[PASTE_ANSWERS]

Do this:
1. Build a 5-row × 4-column matrix: query × LLM. Cell = "cited" / "not cited" / "cited a competitor: [name]".
2. For each cell where I'm not cited but a competitor is, extract the specific angle or format the competitor used that I didn't.
3. Group the findings into 3 to 5 concrete content edits I should make across my site to increase multi-LLM citation rate.
4. Rank the edits by expected citation-rate lift.

Fetch [MY_URL].

Extract every entity that appears on the page: author, publisher, product mentioned, services listed, FAQs, ratings, breadcrumb path, key headings.

Generate a complete JSON-LD @graph with these connected types:
- Article (or BlogPosting, or Course. Pick the best fit.)
- Person (for the author, with sameAs to plausible profiles I can fill in)
- Organization (publisher)
- BreadcrumbList
- FAQPage (from any Q&A on the page)
- Product / Service / Course as applicable
- Any relevant ItemList

Use @id URIs so every entity is referenced from the Article. Output the full JSON-LD block wrapped in a schema tag, ready to paste.

Attached is my sitemap.xml URL list plus, for each URL, its H1 and target keyword.

[PASTE_SITEMAP_DATA]

Do this:
1. Group URLs into topical clusters (pillar page + supporting pages).
2. For each pillar, identify 3 to 5 supporting pages that should link to it, and 2 to 3 outbound links the pillar should send to supporting pages.
3. For each proposed link, write the anchor text as a natural in-paragraph phrase, not the raw keyword.
4. Output a 30-row table: source URL | target URL | anchor text | which paragraph on source to insert into.
5. At the end, flag any pairs of URLs that appear to target the same keyword. Flag them for consolidation or differentiation.

Attached is a 12-month GSC export: query | page | impressions | clicks | position.

[PASTE_GSC_EXPORT]

Do this:
1. Find every query where 2+ of my pages have received impressions AND both have position < 30.
2. For each cannibalized query, list the pages, their impressions, their average position, and their apparent primary topic.
3. Recommend for each query: which page should stay, which should be consolidated (301) or de-optimized (change target keyword), and why.
4. Draft the redirect map: 30 rows of "from → to" for the highest-value consolidations.
5. For consolidated pages, propose a section from the retired page to merge into the surviving page.

Attached is a 30-day server log filtered to Googlebot user-agents. Columns: timestamp | url | status_code | response_size | referrer.

[PASTE_LOG_CHUNK]

Do this:
1. Group URLs by pattern (facet parameters, sort params, session IDs, expired promotions, thin tag pages).
2. Rank patterns by crawl volume (bot hits).
3. For each pattern, judge whether the URLs are worth ranking. If not, propose the specific robots.txt disallow rule, noindex tag, or canonical target.
4. Estimate the % of crawl budget being wasted on non-ranking URL patterns.
5. Output the exact new robots.txt block to deploy and a list of URL patterns to add noindex to.

I need to run a 100-page site audit through Astra. Each page needs the same 12 checks (title, H1, first 100 words, word count, internal link count, schema present, page speed hint, mobile issue, image alt coverage, canonical, meta description, primary keyword density).

I want to spend under $2 total.

Design a workflow that:
1. Batches all 100 pages into one Batch API request (half rate).
2. Loads a single cached system prompt (the 12 checks + output format) that all 100 pages share ($1/M cached vs $10/M standard).
3. Uses the smallest possible per-page payload (URL + rendered text only, not full HTML).
4. Stays under 272K input tokens per request (chunk into 2 requests if needed).
5. Returns one CSV of results, easy to import into Sheets.

Output the exact Batch API request body (JSON), the caching strategy, and estimated cost line-by-line.

I want to connect a live SEO data source to ChatGPT Astra via MCP so Astra can query real keyword volume, SERPs, and backlinks inside the same thread.

For each of these providers, give me a step-by-step setup runbook:
1. a hosted SEO MCP server. Private URL setup, monthly subscription.
2. a self-hosted SEO API MCP. API key + auth.
3. a SERP-only MCP server. SERP-only variant.

For each: (a) what account/plan tier I need, (b) exact connection URL / config, (c) how to verify the connection works (a test prompt), (d) 3 example queries the connection unlocks that Astra couldn't answer without it.

At the end, give me a decision matrix: which MCP for which use case (keyword research vs SERP monitoring vs backlink audit).

I have a working prompt (below) that I want to convert into a named, versioned Codex skill anyone on my team can invoke.

[PASTE_YOUR_WORKING_PROMPT]

Output:
1. A skill definition (name, description, expected inputs, expected outputs).
2. The YAML config to register it in Codex.
3. The rewritten prompt as a system message with input variables clearly parameterized.
4. A 3-example invocation set (what the user types + what the skill returns).
5. Suggested tests to catch regressions when the prompt is updated.

I want to build an end-to-end weekly workflow where:
1. Astra decides what content to publish this week based on my GSC + GBP data
2. A browser agent (Astra's computer-use mode or a partner agent) executes the publishing across GBP posts, Instagram, and my WordPress site
3. Astra reviews the output and logs results

Design the workflow as:
- Reasoning steps (Astra brain, standard rate)
- Execution steps (agent, browser)
- Review steps (Astra brain)

For each step, specify what data flows in, what triggers the next step, and how to detect failure. Include a cost estimate per weekly run, split between reasoning tokens and agent-mode overhead.

Then output the full runbook as a document my ops person can follow next Monday.

I want to build a Custom GPT (or Custom Astra instance) pre-loaded with a specific business's context so I never have to re-paste it.

Business summary:
Name: [BUSINESS]
Industry: [INDUSTRY]
Location(s): [LOCATION]
Services: [SERVICES]
Ideal customer: [ICP]
Current top competitors: [COMPETITORS]
Brand voice: [VOICE]
Known SEO history: [HISTORY]
Constraints: [CONSTRAINTS]

Generate:
1. The full Custom GPT / Astra instruction block (system prompt).
2. A knowledge-file upload plan (which docs to upload, in what order, at what size).
3. A conversation-starter set (5 example prompts the user can click).
4. A monthly-refresh checklist (what to update in the instructions vs the knowledge base).
5. A cost estimate for a typical month of use.

Write a Python script that:
1. Wraps the OpenAI Python SDK for Astra calls.
2. Tracks running input+cache token count per session (thread).
3. Fires a warning at 240,000 tokens (before the 272K cliff).
4. Auto-pauses (returns without sending) at 265,000 tokens.
5. Logs every request's model, mode (standard/Batch/Flex/Fast), token counts, and computed cost to a local SQLite DB.
6. Provides a CLI: python astra-cost.py summary --since 2026-09-01 to see current month spend.

Include the DB schema, error handling for API errors, and a config file for setting the cliff thresholds.

Output the full runnable script, requirements.txt, and setup instructions.