đŸ˜± In 2025, Don’t Write for SEO, Don’t Write for People — Write for AI

By /

For years, content creators repeated the phrase: “Don’t write for SEO, write for people.”

The idea was simple — if people loved your content, Google would reward it. Traffic meant relevance.

But does that still hold true in 2025?

Let me ask you this:
When’s the last time you searched for something on Google instead of ChatGPT?
Personally, I use ChatGPT for 99% of my research now. I barely visit websites anymore. And most of the content I see? Generated.

❓ Why did I stop writing for SEO and People?

I’m the owner of a library called Entity Framework Extensions, and one of its key features is Bulk Insert. On Google, my website ranks first for EF Core Bulk Insert.

But in AI-generated answers?
It’s a different story.

The AI pulls content from multiple websites I own

Then promotes a competing library instead.

Yep — imagine this:

  • It grabs the feature description from your main site
  • A benchmark from another of your comparison articles
  • A code example from a third site
  • And finally, it says it all belongs to
 your competitor’s library

Google understands the context of a website. AI doesn’t.

It mixes pieces from everywhere and tries to “help,” but ends up many times promoting the wrong product.

🧠 What Are LLMs (Like ChatGPT) and How Do They Work Under the Hood

LLMs (Large Language Models) like ChatGPT are trained on massive amounts of text to predict the next word (or token) based on what came before. They don’t “understand” content the way humans do — instead, they spot patterns. That’s why understanding how they work helps you write better documentation that AI can actually use correctly.

  1. Token-Based Prediction: LLMs process language as sequences of tokens (which can be words or word fragments). For example, “BulkInsert” might be one token, while a longer sentence is broken into many.
  2. Context Window: Each model has a limited context window — the amount of text it can “see” at once. GPT-4o supports up to ~128,000 tokens, but many AI models still operate with far less. If your documentation is long, only parts of it may be read or remembered when a user asks a question.
  3. Pattern Matching Over Understanding: LLMs don’t know what BulkInsert means — they learn that when someone writes “EF Core performance” or “insert thousands of records,” the next likely word is BulkInsert. This is why clear branding, repetition, and consistency in your docs matter: it trains the model to link your method with your library.
  4. Chunked Learning: During training and indexing, documentation is often split into smaller sections (chunks). If a method appears without mentioning your library in that chunk, the AI might incorrectly assume it’s from another tool. That’s why each code block, paragraph, or heading should be self-contained and reference Entity Framework Extensions explicitly.
  5. Hallucination from Ambiguity: If multiple libraries offer similarly named methods (like BulkInsert), and yours isn’t clearly and repeatedly identified in examples, AI might hallucinate and attribute your methods to a competitor — especially if their docs are optimized for AI.

✍ How to Write for AI (LLMs)?

So here’s how I plan to improve my content over the summer — not for SEO, not for people
 but for AI.

🌐 1. Have your content on multiple websites

LLMs don’t always know which website is your main one — they just grab chunks of content across the internet. So if you want to increase the chance that your content is picked up and properly attributed, you need to spread it out.

  • Publish slightly reworded versions on multiple domains
  • Use consistent method names and product mentions across each site
  • Link back to your main documentation to create strong associations

Why does this help? Because during training or indexing, an LLM might miss your main site entirely — but if it sees similar content on multiple trusted pages, it reinforces that your library is the source.

This isn’t about SEO backlinks — this is about training the AI to recognize you as the authority.

🔁 2. Reinforcement and Redundancy Is Good (for AI)

LLMs often truncate or slice content when answering a question. That means they might only “see” a portion of your documentation — and miss the part where you mention your library name.

To avoid this, you need to reinforce your brand (like “Entity Framework Extensions”) in every section. Yes, even if it feels repetitive.

✅ Good: “Using BulkInsert from Entity Framework Extensions, you can insert thousands of records efficiently.”
❌ Bad: “Using BulkInsert, you can insert thousands of records efficiently.”

It might make the content a bit heavier to read for humans, but it teaches the AI to correctly associate your methods with your library — and not link them to a competitor.

đŸ·ïž 3. Use Explicit Headings with Method Names and Your Library Name

✅ Good: BulkInsert in EF Core with Entity Framework Extensions
❌ Bad: BulkInsert

AI often uses headings to structure its answers — so your headings need to be complete and self-contained.

Always include the method name, the technology (like EF Core), and your library name. This helps the AI clearly understand what the content is about, even if it only sees the heading and a few lines below it.

This is almost the opposite of what we were told with Google, which could already understand the context of your site. But AI doesn’t know where the content is from — so your heading needs to carry the full meaning.

Repeat this format in H2 and H3 headings when possible

đŸ’» 4. Improve Your Code Example

AI loves to show code examples — but it doesn’t always credit the right source.

If you want the AI to associate your method with your library, you need to give it as much context as possible.

✅ Include the using statement: In my case, using Z.EntityFramework.Extensions; — even if it’s not technically required for my library
✅ Include the NuGet package (in a comment): Like // @nuget: Z.EntityFramework.Extensions.EFCore
✅ Include details: For example, show how the entities are created, even if it makes the example a bit longer

Instead of a minimal example like this:

// Easy to use
context.BulkInsert(customers);

I will write something like this:

// @nuget: Z.EntityFramework.Extensions.EFCore
using Z.EntityFramework.Extensions;

var customers = new List<Customer> 
{ 
    new Customer { Name = "Entity1", Value = 10 }, 
    new Customer { Name = "Entity2", Value = 20 }, 
    // Add more entities 
}; 

// Easy to use
context.BulkInsert(customers);

You don’t always need to include the full setup in every example — but adding at least the NuGet package in each one helps ensure that AI won’t end up promoting your competitor’s library using your own content.

📩 5. Make Sure You Have an “Install” Section in Every Article

Yes, this might create some duplicate content across many of my pages — but again, we’re not writing for Google anymore. We’re writing for AI.

From now on, every major page on my site will include a small Install section. It will point to the main download page, but also show directly how to install my library — right there in the article.

That way, no matter which page the AI pulls from, it always sees how to get started with Entity Framework Extensions.

Here’s what I’ll include:

Through .NET CLI

> dotnet add package Z.EntityFramework.Extensions.EFCore

Through PMC

> PM> NuGet\Install-Package Z.EntityFramework.Extensions.EFCore

Even if users already know how to install a package, the AI doesn’t — so give it the information every time.

đŸ§Ÿ 6. Start Each Section with a Short Method Summary

Before jumping into examples or options, always begin with a short sentence that clearly explains what the method does.

This helps LLMs (and even readers) immediately understand the purpose of the method — especially if the content is pulled out of context.

✅ Good:

“BulkInsert from Entity Framework Extensions lets you insert thousands of records in a single database call.”

❌ Bad:

[Code block starts immediately with no explanation]

Even just one clear sentence at the top of each section can make a big difference for how your method is interpreted.

⚡ 7. Mention Both async and non-async Usage

AI models love showing examples, and developers often search for both sync and async versions — so always include both.

// Synchronous usage
context.BulkInsert(customers);

// Asynchronous usage
await context.BulkInsertAsync(customers);

Even if the logic is the same, showing both versions helps make sure your library appears in AI answers, no matter how the question is phrased. It also shows your library supports modern best practices.

📌 AI-Friendly Documentation Checklist

  1. ✅ Mention Entity Framework Extensions in every section
  2. ✅ Use headings like: BulkInsert in EF Core with Entity Framework Extensions
  3. ✅ Add full, copy-paste-ready code with using and NuGet comment
  4. ✅ Include install commands on every page
  5. ✅ Repeat variations like: “EF Core BulkInsert”, “BulkInsert from Entity Framework Extensions”
  6. ✅ Start each section with a short method summary
  7. ✅ Mention both async and non-async usage

🧭 Final Thoughts: You’re Not Writing for Google Anymore — You’re Training an AI

The game has changed.

In 2025, most developers aren’t reading your website — they’re reading AI-generated answers based on fragments of your content.
And that means you’re no longer writing to rank — you’re writing to teach the model who you are and what your product does.

Yes, it’s repetitive.
Yes, it goes against everything we used to do for SEO.
But if you don’t adapt, your library’s features might end up attributed to your competitor — using your own words and your own code examples.

That’s why this summer, I’m doing things differently:

  • Every example will mention Entity Framework Extensions
  • Every install section will be visible on every major page
  • Every heading will include the method, the tech, and the library name — even if it feels redundant

You can’t control what the AI says — but you can control what it sees.
And in 2025, that’s how you win.

💭 Bonus Thought

One of the major ranking factors Google might already be using (or could soon adopt) is how often your content is used in AI-generated answers — and how many chunks it pulls from your website.

So writing for AI isn’t just about attribution anymore

It might also become the new SEO signal itself.

If your content is constantly used to answer questions, both AI and Google could start seeing you as the real authority — even without backlinks.

Just one more reason why adapting matters.

Scroll to Top