When I was writing code full-time five years ago, I Googled error messages, opened five tabs, and scanned Stack Overflow, docs, GitHub issues, and blog posts to get to the root cause.
My how the times have changed.
Now, you paste the error message into ChatGPT, Claude, Cursor, or Perplexity and simply ask for a direct answer...or even better, you just ask your coding agent to solve the problem for you!
Clearly, this behavior shift matters if you're building, documenting, or marketing developer tools, and that's why interest in AEO is on the rise.
I spent about 10 years as a CTO and software engineer before moving into content and starting Draft.dev. Since then, our team has worked with hundreds of technical companies, including Docker, Cloudflare, Okta, JetBrains, and vCluster.
Over the past 18 months, we have been working with clients like these on AEO, and we are starting to see patterns in what gets cited by answer engines and what gets ignored.
This guide is my attempt to make AEO practical for software developers. Let's dive in!
What AEO means for software developers
AEO stands for Answer Engine Optimization. GEO stands for Generative Engine Optimization.
The terms are still a little fuzzy, but the practical question is simple:
Can a Large Language Model understand what your website does, how to use it, and when it's a good fit.
This matters for any tool that has:
- API docs
- Tutorials
- Architecture guides
- Product comparisons
- Migration guides
- Error handling docs
- Integration examples
- README files
You want LLMs to understand all of these.
As a brief aside, AEO does not really replace traditional SEO. Google still sends a lot of traffic, and plenty of developers still search for things directly. Ranking and being indexed still matters.
The difference is that the search result is less likely to be ten blue links. It might be an AI-generated summary, a Perplexity answer, a ChatGPT recommendation, or a code assistant suggesting an implementation path. The implementation and tactics you need to show up consistently in LLMs are slightly different, so that's why I'm writing this today.
Why developer content is different
Now, I'll assume if you're reading this, you're writing developer-facing content. That's what Dev.to is for, right?
This matters because developer searches are different. They're full of context that might be incredibly nuanced.
A generic searcher might ask:
What is the best analytics tool?
But a developer is more likely to ask:
What is the best open source product analytics tool for a self-hosted Next.js app with event batching and warehouse export?
That second query has constraints: a specific framework, hosting model, performance needs, data flow, and probably a few hidden concerns about pricing and compliance.
This is why shallow content fails to reach a technical audience. A generic post like "What is feature flagging?" may still get indexed, but AI tools can answer that directly without sending anyone to your site.
A more useful article might be:
How to add percentage-based feature flags to a Node.js API using Redis
That topic is more specific. It gives you room to show implementation detail, tradeoffs, failure modes, and version-specific advice.
AI systems can summarize generic content. Developers rarely trust generic content when they are making implementation decisions.
The AEO checklist for technical content
1. Give every page a clear technical job
Each article or docs page should answer a specific developer question.
Examples:
- How do I connect this SDK to a Next.js app?
- How does this compare to PostHog for product analytics?
- Does this work with SOC 2 requirements?
- What happens if the API rate limit is exceeded?
- How do I migrate from version 2 to version 3?
If a page has no clear job, answer engines have to infer its purpose. That makes the page less useful to machines and people.
A quick test: if you cannot describe the page as "This helps a developer do X," the page is probably too vague.
2. Use headings that match real questions
A lot of technical content still uses headings like this:
## Installation
## Authentication
## Error Handling
## Alternatives
Those are fine, but question-based headings are often clearer:
## How do you install the SDK?
## How do you authenticate requests?
## What errors should you handle?
## How does this compare to PostHog?
This helps readers scan the page, and it gives answer engines a cleaner map of the content.
3. Put the direct answer near the heading
Do not make readers hunt for the answer.
A good pattern looks like this:
## How do you authenticate requests?
Authenticate requests by sending a bearer token in the `Authorization` header. Store the token in an environment variable and avoid committing it to source control.
Then follow with code, edge cases, and links to deeper docs.
The first sentence matters. If an answer engine is trying to extract a concise response, make the response easy to find.
4. Include working code snippets
This is where developer content has an advantage over generic marketing content.
A weak example:
Install our SDK and call the API.
A better example:
const response = await fetch("https://api.example.com/v1/events", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.EXAMPLE_API_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
event: "signup_completed",
userId: "user_123"
})
});
if (!response.ok) {
throw new Error(`API request failed: ${response.status}`);
}
This example is more useful because it includes:
- The endpoint shape
- The HTTP method
- The auth pattern
- The content type
- The request body
- Basic error handling
A developer can adapt it. An answer engine can understand it. Both outcomes are better than a vague paragraph.
5. Add structured data where it fits
Schema will not save weak content, but it can help machines understand the type of page they are reading.
Google's structured data documentation is the best source to start with, but a simple TechArticle example might look like this:
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "TechArticle",
"headline": "How to Add Webhooks to a Node.js App",
"description": "A practical guide to receiving, verifying, and testing webhooks in Node.js.",
"author": {
"@type": "Person",
"name": "Your Name"
},
"programmingLanguage": "JavaScript"
}
</script>
Use this where it fits your site. Do not treat it as a ranking hack.
6. Keep examples current
Outdated developer content is worse than vague content because it can waste someone's time.
If your tutorial uses a deprecated API, old package name, or outdated setup command, developers will notice quickly. AI systems may also repeat those stale instructions.
Add a short tested block to technical tutorials:
Tested with:
- Node.js 22
- Next.js 15
- Example SDK 3.4.1
Then revisit important posts on a schedule. For fast-moving topics, once a year may not be enough.
7. Create comparison pages that are honest
Developers ask AI tools which product to use.
If your site does not explain where your tool fits, other sources will do it for you.
Good comparison content includes:
- Who each tool is best for
- Tradeoffs
- Pricing model differences
- Integration limits
- Migration notes
- Code or architecture examples
- Cases where your tool is the wrong choice
That last point matters. A comparison page that claims your product wins every category is not credible.
Make your content easier to crawl and quote
A lot of AEO work is basic technical hygiene.
If the main content is hard to crawl, hidden behind JavaScript, locked in a PDF, or trapped behind a form, answer engines may have little to work with.
A few practical checks:
- Render core article and docs content in HTML.
- Avoid putting important explanations only in images.
- Add transcripts for videos and webinars.
- Publish crawlable summaries for gated reports.
- Use stable canonical URLs.
- Keep docs URLs descriptive and predictable.
You can do a quick raw HTML check with curl:
curl -L https://example.com/docs/webhooks | head -n 40
If the response only contains a JavaScript shell and no meaningful content, crawlers may need extra rendering work to understand the page. Google can render JavaScript in many cases, but you should not assume every AI retrieval system will process your site the same way.
You can also inspect whether specific text is present in the initial HTML:
curl -L https://example.com/docs/webhooks | grep -i "verify webhook"
This is a crude test, but crude tests catch a surprising number of problems.
Brand mentions matter more than most developers expect
One thing we are seeing in Draft.dev's AEO work:
LLM visibility is influenced by how a brand is described across the web, not only by what the company says on its own site.
That does not mean you should spam links all over the internet, but it does mean you need accurate third-party context to support your product in places developers would expect to read them.
For developer tools, this might include:
- Dev.to tutorials
- GitHub READMEs and examples
- Reddit comments with real substance
- Partner blogs
- Comparison posts
- Community docs
- Newsletters
If you want your product associated with "open source feature flags for Node.js," it helps if multiple credible pages make that association in specific language.
The goal is not to trick the models; the goal is to make the correct associations easier to find.
What is not working
Based on what we have seen so far, these patterns are weak for AEO:
Generic "What is X?" articles
High-level definitions are easy for AI tools to answer directly. They may still have a place in a content library, but they are less likely to create meaningful developer engagement.
AI-written filler with no technical judgment
AI can help with outlines, summaries, and editing. It is much weaker when asked to replace practical experience.
This is especially true in developer content, where a small technical mistake can make the whole article feel unreliable.
Gated reports with no crawlable version
Gated assets can still work for lead generation, but if all the useful information is hidden behind a form, answer engines cannot easily cite it.
A better pattern is to publish a crawlable summary or ungated companion article.
Old tutorials with deprecated APIs
If your docs teach an outdated implementation, AI tools may repeat it. That creates a bad experience for developers and a bad association with your brand.
Thin landing pages with no examples
Claims like "built for developers" mean little without code, architecture diagrams, use cases, or clear technical constraints.
Comparison pages that pretend your tool always wins
Developers are skeptical. So are the systems trained on developer content. Honest tradeoffs are more useful than sales copy.
A practical AEO workflow for developers
If you want to start this week, I would keep it simple.
- Pick one technical topic your tool should be known for.
- List 10 real developer questions around that topic.
- Search those questions in ChatGPT, Perplexity, Claude, and Google AI Overviews.
- Record which brands and sources appear.
- Audit your docs and blog for missing answers.
- Publish or refresh content with direct answers, code, tradeoffs, and schema.
- Create one useful external mention on a developer-focused site.
- Re-check the same questions monthly.
A lightweight tracking sheet is enough at first:
| Query | ChatGPT | Perplexity | Google AI Overview | Our page cited? | Competitors cited |
|---|---|---|---|---|---|
| best webhook tool for node.js | TBD | TBD | TBD | No | A, B, C |
| how to verify webhooks in express | TBD | TBD | TBD | Yes | B, C |
| posthog alternative for self-hosting | TBD | TBD | TBD | No | A, D |
The point is to build a repeatable feedback loop. You need to know what answer engines currently say before you can improve your odds of appearing there.
Tools worth using
The tooling around AEO is still early, but a few tools are useful now.
- Google Search Console: Useful for search performance, Discover data, and indexing checks.
- Scrunch: We use this at Draft.dev for LLM visibility tracking across AI search surfaces.
- Ahrefs: Still useful for keyword research, competitor research, and backlinks.
- Screaming Frog: Useful for crawling technical content and finding metadata, canonical, and rendering issues.
I wrote about these and a few other good SEO/AEO tools recently in case you're interested.
A deeper guide for developer tools
If you work on marketing, docs, or DevRel for a developer tool, Draft.dev put together a deeper report here:
The guide includes current findings from our client work and research, including:
- 49% of search results now include AI Overviews
- 96% of dev marketing teams have tried AI tools
- Only 7% find AI tools "very useful"
- Human-written content generated 5.4x more traffic than AI-only content in the referenced HubSpot data
AEO will keep changing, but the durable part is straightforward: publish technically accurate content that answers real developer questions with enough detail to be useful.
