DEV Community: AgustaON

My company ranked #1 on Google but ChatGPT had never heard of us. Here's what I did about it.

AgustaON — Mon, 20 Jul 2026 08:25:14 +0000

Last month my manager forwarded me a Slack message from our founder that just said: "Ask ChatGPT what our company does. Then panic."

So I did. I opened ChatGPT and typed our company name. It confidently told me about a completely different company with a similar name. Then I asked it to "recommend a good [our category] tool" — the exact thing we sell — and it named three competitors. Not us. Never us.

Here's the kicker: we rank #1 on Google for our main keywords. Our SEO is genuinely good. And it turns out that means almost nothing to an LLM.

I went down a rabbit hole for two weeks. This is the practical version of what I learned, with the actual code that moved the needle.

Why "good SEO" doesn't transfer to AI

Google crawls, indexes, and ranks pages. Its algorithm is built around links, keywords, freshness, and hundreds of ranking signals. You can win that game with backlinks and on-page optimization.

LLMs work differently. When you ask ChatGPT or Perplexity "what's the best X," the model isn't ranking a list of pages — it's generating an answer from an internal representation of the world, sometimes augmented with live retrieval. For your business to show up, the model needs to have formed a clear, confident, consistent understanding of what you are.

That understanding comes from:

How clearly your own site describes you (in plain language, not marketing-speak)
How consistently you're described everywhere else (directories, social profiles, other sites)
Whether machines can parse your site at all (structured data, semantic HTML)

We were failing all three, and none of them showed up in a normal SEO audit.

Problem 1: Our homepage was written for humans who already knew us

Our hero section said something like "The intelligent growth platform for modern teams." Beautiful. Meaningless to a model. An LLM reading that has no idea what we sell.

The fix was boring but effective: we rewrote the first paragraph of the homepage to be almost aggressively literal. One sentence that a stranger — or a model — could repeat back accurately:

"[Company] is a [exact product category] that helps [specific audience] do [specific outcome]."

That's it. No adjectives doing load-bearing work. After the change, re-testing showed the model could actually describe us.

Problem 2: No structured data

This is the technical one and where devs can make the biggest difference fast.

Most sites have zero JSON-LD structured data. It's invisible to human visitors but it's a direct, machine-readable statement of what this entity is. If you give an AI crawler explicit facts, it doesn't have to guess.

Here's the minimum I'd add to any company homepage — a <script type="application/ld+json"> block in the <head>:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Your Company",
  "url": "https://yourcompany.com",
  "description": "A one-sentence, plain-language description of exactly what you sell and who it's for.",
  "sameAs": [
    "https://www.linkedin.com/company/yourcompany",
    "https://twitter.com/yourcompany",
    "https://github.com/yourcompany"
  ]
}
</script>

The sameAs array matters more than it looks — it links your entity to every other profile that describes you, which reinforces consistency (problem 3).

If you sell specific products, add Product schema too:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Product Name",
  "description": "What it does, in plain language.",
  "brand": { "@type": "Brand", "name": "Your Company" },
  "offers": {
    "@type": "Offer",
    "price": "4.99",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock"
  }
}
</script>

For content pages, FAQPage and Article schema help LLMs extract answers directly. The pattern is always the same: stop making the machine infer, and just tell it.

Validate everything with Google's Rich Results Test or Schema.org's validator before shipping — malformed JSON-LD does nothing.

Problem 3: We described ourselves five different ways

Our website said one thing, our LinkedIn bio said another, our Crunchbase entry was three years out of date, and our Twitter bio was a joke (literally, it was a pun). To a model trying to build a confident picture, that inconsistency is noise. It'll favor a competitor whose story is the same everywhere.

Fixing this wasn't code — it was a boring afternoon of copy-pasting one canonical description into every profile we own. But it measurably helped.

The part where I admit I used a tool

I could check some of this manually — read our own copy, eyeball the markup, run the schema validators. But two things were painful to do by hand:

Writing correct JSON-LD for every page type from scratch, matching the right schema.org vocabulary
Actually measuring whether AI assistants mention us — you can't eyeball that, you have to query them with real buyer questions and check the answers

A teammate pointed me at Greater Than Services, which runs an audit specifically for this (they split it into CRO / GEO / ASO — human, AI-search, and AI-agent readability). The useful part for me as a dev: instead of a report that says "add structured data," it generates the actual JSON-LD and meta tags for your specific site, ready to paste. It also runs the "does AI name you" test automatically across a few assistants, which is the measurement I couldn't be bothered to script myself.

The free preview was enough to see our scores; the full report was a few dollars. I'm not affiliated with them — it just saved me from writing schema by hand for 6 page types, so it's earned a mention. There are other ways to do this; that's the one that worked for me. If you'd rather DIY, everything above is the manual path.

The 30-second test you should run right now

Regardless of tooling, do this before you close the tab:

Open ChatGPT (or Perplexity, or Gemini).
Type: "What does [your company] sell, and who is it for?" — do not paste your URL.
Read what comes back.

If it's vague, wrong, or blank, that's not a hypothetical future problem. That's real prospects, right now, asking an AI for exactly what you sell and getting pointed at someone else.

We went from "ChatGPT thinks we're a different company" to "ChatGPT describes us correctly" in about two weeks, mostly with the three fixes above. The code part — structured data — was genuinely the highest-leverage thing, which is why I'm writing this on dev.to and not on LinkedIn.

Ship the JSON-LD. Fix your copy. Be consistent. The models are already answering questions about your business — you just want to be in the answer.

Ran into weird edge cases with schema for a specific page type? Drop them in the comments — happy to compare notes.

We looked at where AI actually gets its answers. Your homepage barely matters.

AgustaON — Mon, 20 Jul 2026 08:24:45 +0000

If you've read anything about "getting cited by AI" in the last year, the advice was probably some combination of: add structured data, write clearer copy, fix your headings. All reasonable. We build a tool that does exactly that kind of analysis, so I'm biased toward it being useful.

Then we started logging where the AI answers were actually pulling from — the source types cited when an assistant answers a buying question in a given category — and the data made me rethink the priority order.

Company homepages were rarely the primary source.

What the citation mix actually looks like

When you ask ChatGPT, Perplexity, Gemini, or Claude something like "best project management tool for a small agency," the model (usually with web search on) assembles an answer from retrieved documents. Log what those documents are across a category and a pattern shows up fast. Roughly:

Review platforms — G2, Capterra, Trustpilot, category-specific review sites
Industry directories — niche listings, "best X tools" databases
Editorial roundups — blog posts titled "12 best X for Y in 2026"
Forums and communities — Reddit threads, Stack Overflow, niche forums
Brand-owned sites — usually the smallest slice

The exact mix varies a lot by category — developer tools skew heavily toward forums and GitHub, local services skew toward review sites and maps — but brand sites consistently underperform the intuition.

This makes sense once you think about retrieval rather than ranking. The model isn't looking for the most authoritative page about you. It's looking for documents that compare options in your category. Your homepage says "we're the best." A G2 category page says "here are 40 tools, ranked, with reviews." Guess which one is more useful for answering a comparison question.

The uncomfortable implication

You can have perfect technical SEO, flawless JSON-LD, a beautifully clear homepage — and still be absent from the answer, because the answer was assembled from four sources you're not on.

That doesn't make on-page work pointless. It makes it necessary but not sufficient, and it changes the order you should do things in:

Be present on the source types your category's answers are built from
Be parseable so that when the model does encounter you, it correctly understands what you are

Most advice covers step 2 exclusively. Step 1 is unglamorous, non-technical, and does more.

The technical half (step 2) — what actually helps

Since this is dev.to, here's the part you can ship this afternoon.

Make your entity unambiguous

The single highest-leverage markup is Organization schema with a populated sameAs. It links your site to every other profile that represents you — which is exactly how a retrieval system corroborates that scattered mentions are the same entity:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Your Company",
  "url": "https://yourcompany.com",
  "description": "One plain sentence: what you sell and who it's for.",
  "sameAs": [
    "https://www.g2.com/products/your-company/reviews",
    "https://www.crunchbase.com/organization/your-company",
    "https://github.com/yourcompany",
    "https://www.linkedin.com/company/yourcompany"
  ]
}
</script>

Note what's in that sameAs array: the review site and the directory. You're explicitly connecting yourself to the sources that actually get cited.

Write passages that survive extraction

Retrieval works on chunks, not pages. A paragraph that only makes sense after reading the three above it is a bad chunk. A self-contained paragraph that answers one question is a good one.

Practically, that means:

<!-- Bad: requires context to be useful -->
## How it works
It integrates seamlessly and handles this automatically for you.

<!-- Good: survives being ripped out of context -->
## How does [Product] handle rate limiting?
[Product] applies a token bucket per API key, defaulting to 100
requests per minute. Limits are configurable per plan, and 429
responses include a Retry-After header.

The second one can be lifted directly into an answer with attribution. The first can't be lifted at all.

FAQPage schema formalizes this — it's a machine-readable declaration of "here is a question and here is its self-contained answer":

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [{
    "@type": "Question",
    "name": "How does the API handle rate limiting?",
    "acceptedAnswer": {
      "@type": "Answer",
      "text": "A token bucket per API key, defaulting to 100 requests per minute, configurable per plan. 429 responses include a Retry-After header."
    }
  }]
}
</script>

Don't block the crawlers you want

Easy to get wrong, especially if someone added a blanket rule during a scraping panic. Check your robots.txt for the AI crawlers you actually want indexing you (GPTBot, PerplexityBot, ClaudeBot, Google-Extended, among others). Blocking them is a legitimate choice — just make sure it's a choice and not a leftover.

Comparison pages are retrieval bait

If the cited documents are mostly comparison content, one thing you control is publishing genuinely useful comparison content yourself. An honest "X vs Y" page — including where you lose — is far more likely to be retrieved for a comparison query than a features page. It also tends to be the highest-intent traffic you'll get.

The honest caveats

Two things worth saying plainly, because a lot of content in this space overclaims:

Nobody can guarantee AI citations. You can improve the signals that correlate with being retrieved and understood. You cannot control what any model outputs next week. Anyone selling you a promised ranking in ChatGPT is selling you something they can't deliver.

This is a moving target. Retrieval behavior differs across engines and changes with model updates. What I described is a snapshot, not a law. Measure your own category rather than trusting a generic list — including this one.

How to check your own category

Free version, takes ten minutes: open each of the four assistants, ask three or four buying questions a customer in your category would ask, and note which domains get cited. Not which companies get named — which domains get linked. Tally them. The pattern usually appears within a dozen questions.

If you'd rather not do it by hand, Greater Than Services (what I work on) runs those queries across ChatGPT, Perplexity, Gemini and Claude and gives you the source-type breakdown for your specific category, plus the schema fixes as copy-paste code. Free preview, no signup. But the manual method above genuinely works and costs nothing — the point of this post is the finding, not the tool.

TL;DR

Your homepage's job is to be unambiguous when a model encounters it. Getting encountered mostly happens elsewhere — on the review sites, directories, roundups and forums that AI answers are actually assembled from.

Fix the markup. Then go get listed.

Curious what the citation mix looks like in other categories — if you run the manual check for yours, drop what you find in the comments. Especially interested in whether dev-tool categories really are as forum-heavy as they look.