Bonus: SEO, AEO, GEO and AIO: Getting Found by Search Engines and AI
番外:SEO、AEO、GEO、AIO:讓搜尋引擎與 AI 找到你
What SEO, AEO, GEO and AIO actually mean and where they overlap, followed by concrete steps for a developer blog or API docs: crawlability and rendering, sitemaps, canonical URLs, JSON-LD, Core Web Vitals, question-shaped answers, llms.txt, robots.txt rules for AI crawlers, and measurement.
In this article
- What this article solves
- Step 1: Pin down the four terms
- Step 2: Understand where they overlap and where they differ
- Step 3: Crawlable and renderable
- Step 4: Sitemaps, canonical URLs and page metadata
- Step 5: Structured data with JSON-LD
- Step 6: Structuring content for people, answer engines and AI alike
- Step 7: llms.txt and robots.txt rules for AI crawlers
- Step 8: Page speed, Core Web Vitals and measurement
- Common pitfalls
- Key takeaways
- Series wrap-up
In the previous article, “Writing a Claude Code Skill That Cites Its Sources”, we made every AI answer come with sources you can check. This bonus article steps away from the code itself for a while: once the service, its API documentation and the technical blog are all live, how do you make sure people and AI can find them, understand them, and are willing to cite them?
What this article solves
Writing a good piece of API documentation, a technical article or the description page of an open-source project and putting it online does not mean it will be found automatically. In the past, "being found" was almost the same as "appearing near the top of search engine results"; now, more and more people ask an AI assistant directly or read the AI summary at the top of the search results page, getting a ready-made answer that may come with a few source links, or may not lead them to click through to any website at all.
So a string of acronyms has appeared: SEO, AEO, GEO, AIO. They sound like four different technologies, but in practice most of the groundwork is shared; the difference lies in "who presents the final answer". The goals of this article are:
- To pin down what each term refers to, and which usages are themselves inconsistent.
- To work step by step, in ways developers are familiar with, towards a site that "search engines can crawl and understand, and that AI can easily cite correctly".
- To know which practices are backed by documentation and which are only proposals or rumours, so you do not spend time on the latter.
Taking this series as an example, you can imagine two kinds of page that need to be found: one is a technical article like those in this series, the other is the public API documentation page for the order service (for example the description of POST /orders). The examples that follow all target these two kinds of page.
Step 1: Pin down the four terms
| Term | Full name | Goal | Where the answer appears |
|---|---|---|---|
| SEO | Search Engine Optimization | Get pages crawled and indexed by search engines, and ranked high for relevant queries | Traditional blue-link results |
| AEO | Answer Engine Optimization | Get the page's content used directly as "the answer" | Featured snippets, "People also ask", voice assistant answers |
| GEO | Generative Engine Optimization | Get generative AI to cite and mention your content when producing answers | Answers with sources, such as Google's AI Overviews, ChatGPT search, Perplexity and Copilot |
| AIO | Depends on who is using it | Usage varies | See below |
SEO is the oldest and most mature field. The search engine process is roughly: a crawler fetches the page → renders JavaScript if needed → analyses the content and adds it to the index → when a user searches, results are selected from the index and ranked. SEO deals with every stage of this process.
AEO starts from the observation that for some queries, users do not want a list of links but an answer, for example "what is context in Go" or "what does HTTP 409 mean". A search engine's featured snippet, or the sentence a voice assistant reads out, is a fragment extracted from some web page. AEO is about organising content so it is easy to extract as an answer: a clear question, the answer immediately after it, and precise wording.
GEO is a term that has emerged in recent years with generative AI search. A generative answer first retrieves relevant web pages, then a language model synthesises them into a piece of text, possibly marking the cited sources. GEO is about whether your content gets retrieved, whether the model uses it, and whether it is correctly attributed to you when cited.
AIO is the most confused of the lot. Some people use it for "AI Optimization", a general term for all kinds of optimisation aimed at AI, meaning roughly the same as GEO; others use it for Google's "AI Overviews" product feature itself, as in "does this query show an AIO". There are also other terms such as LLMO and AI SEO. None of these has an authoritative standard definition, so when you come across one, it is best to first check which one the other person means. This article spells out the full name whenever it uses one, to avoid confusion.
Tip: However many terms there are, underneath they are almost all the same thing: content must first be crawlable and understandable before there can be any talk of ranking, being extracted as an answer or being cited by AI. Without an SEO foundation, there is nothing to build AEO or GEO on.
Step 2: Understand where they overlap and where they differ
Putting all three in one diagram makes the relationships much clearer:
Figure: SEO is the shared foundation; AEO and GEO are built on top of it. Both require content that is clear and extractable; the difference is who assembles the answer.
What they share:
- Pages must be crawlable, renderable and indexable. AI retrieval systems usually rely on a search engine's index or on their own crawlers, and both need accessible HTML.
- Content must be correct and clear, with a clear topic and structure.
- Trust signals (author, sources, last-updated date) help all three.
Where they differ:
| Aspect | SEO | AEO | GEO |
|---|---|---|---|
| What success looks like | The user clicks through to the page | Your sentence becomes the answer | You are listed as a cited source or mentioned |
| Unit of content | The whole page | A short, self-contained answer | Paragraphs and facts that stand on their own and can be cited |
| Main measurement | Impressions, clicks, rankings | Whether you win the featured snippet | Citations in AI answers and referral traffic from AI |
| Degree of control | Higher; official documentation and tools exist | Medium | Lower; each platform's mechanism is opaque and changes fast |
The last row matters: GEO currently has no set of rules as fully public as a search engine's, and many of the "GEO tips" online are speculation or observations of individual cases. The safer strategy is to put your effort into groundwork that is backed by documentation and benefits all three at once, which is what the following steps cover.
Step 3: Crawlable and renderable
Everything starts with "can the crawler get the content". For developers, the most common problem is client-side rendering: the page's HTML contains only an empty <div id="app">, and all the content is generated by JavaScript in the browser. Google's crawler renders JavaScript, but rendering may be queued for later; many other crawlers, including quite a few AI crawlers, do not necessarily run JavaScript, so all they get is an empty shell.
For content-centred pages such as technical articles and API documentation, the most reliable approach is server-side rendering or static generation: the HTML contains the full body text as soon as it is sent. You can check yourself like this:
# Fetch the page without running JavaScript, and confirm the body text is in the HTML
curl -s https://docs.example.com/articles/go-context/ | grep -c 'Cancellation, Timeouts'
# Check the status code and redirect chain: the end result should be 200, not a soft 404 or multiple hops
curl -sIL https://docs.example.com/articles/go-context | grep -iE '^(HTTP|location)'
# Fetch with a specific User-Agent to confirm the firewall or CDN is not blocking crawlers by mistake
curl -s -o /dev/null -w '%{http_code}\n' -A 'GPTBot' https://docs.example.com/
# Check that robots.txt and the sitemap are reachable
curl -s https://docs.example.com/robots.txt
curl -s https://docs.example.com/sitemap.xml | headA few things here are often overlooked:
- Status codes must be honest. A page that does not exist should return 404, not 200 with "page not found" content (a soft 404). If the documentation site is served by a Go service,
http.NotFoundis the correct response; a page that has moved should get a 301 permanent redirect to the new URL. - WAF and bot protection. Bot protection rules in a CDN or firewall may keep search engine or AI crawlers out. Whether you allow AI crawlers is a choice (Step 7), but it should be a deliberate setting, not a side effect of protection rules.
- Internal links. Crawlers discover pages through links. Linking articles in a series to each other, with every article having a previous and next link, helps both users and crawlers. Use ordinary
<a href>links, not click events that only JavaScript can trigger.
Step 4: Sitemaps, canonical URLs and page metadata
Once you are sure the content can be fetched, the next step is to tell search engines "which pages exist" and "which URL is the original".
A sitemap is an XML list of the URLs you want indexed, each with its last-modified time (lastmod). lastmod should reflect when the content was really modified, not be set to today on every build; otherwise search engines gradually stop trusting the field. A sitemap can be declared in robots.txt with Sitemap:, or submitted directly to Search Console and Bing Webmaster Tools.
canonical deals with duplicate content. The same article may be reachable at several URLs: with or without a trailing slash, with or without tracking parameters, over http and https. Using <link rel="canonical"> on the page to point to the original URL you have chosen makes search engines consolidate signals onto that one URL. The site's own internal links, the sitemap and the canonical URL should all use exactly the same URL form.
The <head> of a technical article page can look roughly like this:
<head>
<meta charset="utf-8" />
<title>context: Cancellation, Timeouts and Passing Data | Go Microservices Series</title>
<meta
name="description"
content="Use context to pass cancellation signals, timeouts and request-scoped data between Go services, and avoid common misuses."
/>
<link rel="canonical" href="https://docs.example.com/articles/go-context/" />
<link rel="alternate" hreflang="zh-Hant" href="https://docs.example.com/articles/go-context/" />
<link rel="alternate" hreflang="en" href="https://docs.example.com/en/articles/go-context/" />
<meta property="og:type" content="article" />
<meta property="og:title" content="context: Cancellation, Timeouts and Passing Data" />
<meta property="og:url" content="https://docs.example.com/articles/go-context/" />
<meta property="og:image" content="https://docs.example.com/og/go-context.png" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
</head>title and description are not necessarily shown as-is in search results, but they are important inputs for search engines to understand the page's topic and generate the result snippet. Every page needs its own unique title and description that accurately describe that page's content; do not share one set across the whole site. If the site has multiple language versions, use hreflang to mark how they correspond to each other. Open Graph tags affect what the preview looks like when the link is shared on social media or in messaging apps.
Step 5: Structured data with JSON-LD
Structured data uses the schema.org vocabulary to describe the page's content in a machine-readable way: this is an article, who the author is, when it was published, which questions and answers this page contains. Google recommends the JSON-LD format, placed in a <script type="application/ld+json">, which does not affect the page's visible content.
The types most commonly used for technical articles and API documentation are:
- Article / TechArticle: title, author, publication and modification dates, the series it belongs to.
- Person: the author's name, URL and related profile pages (
sameAs), linking the author's identity to their information on other platforms. - FAQPage: questions and answers that actually exist on the page. Note that since 2023 Google has restricted FAQ rich results to a small number of well-known government and health websites, so adding FAQPage to an ordinary site usually no longer shows expanded questions and answers in results; but it is still the correct way to describe the page's structure, and other systems may use it too.
- BreadcrumbList: the page's position within the site.
Below is an example of JSON-LD for an article page, using @graph to put the article, the author and the questions and answers in one piece of data (placed inside a <script type="application/ld+json">):
{
"@context": "https://schema.org",
"@graph": [
{
"@type": "TechArticle",
"@id": "https://docs.example.com/articles/go-context/#article",
"headline": "context: Cancellation, Timeouts and Passing Data",
"description": "Use context to pass cancellation signals, timeouts and request-scoped data between Go services.",
"inLanguage": "zh-Hant",
"datePublished": "2026-11-15",
"dateModified": "2026-11-15",
"author": { "@id": "https://docs.example.com/#author" },
"isPartOf": { "@type": "CreativeWorkSeries", "name": "Go Microservices Series" },
"mainEntityOfPage": "https://docs.example.com/articles/go-context/"
},
{
"@type": "Person",
"@id": "https://docs.example.com/#author",
"name": "Author Name",
"url": "https://docs.example.com/about/",
"sameAs": ["https://github.com/example"]
},
{
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "What belongs in context.Value?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Only data that shares the request's lifetime and crosses API boundaries, such as a request ID or tracing information; do not use it to pass a function's required parameters."
}
}
]
}
]
}Structured data has one iron rule: its content must match what is visible on the page. Marking up questions and answers that are not on the page, or invented ratings or authors, not only brings no benefit but may also be treated as a guideline violation. Once it is written, you can check the syntax with Google's Rich Results Test and schema.org's validator.
Step 6: Structuring content for people, answer engines and AI alike
Technical settings only get your content "through the door"; what really decides whether it becomes an answer or gets cited by AI is how the content itself is written. The good news is that writing that helps AEO and GEO is just as friendly to human readers:
- Question-shaped headings, with the answer right after. Write the heading as the question readers will ask (for example "Does
http.Server.Shutdownwait for requests to finish?"), answer it directly in one or two sentences in the first paragraph under the heading, then go into detail. This "answer first, explanation after" structure is the easiest to extract as a featured snippet, and the easiest for generative systems to adopt as a whole paragraph. - Every paragraph can stand on its own. AI retrieval often works paragraph by paragraph, and the extracted paragraph may be taken out of context. In a paragraph, avoid references that depend on earlier text, such as "as mentioned above" or "this", and write key terms out in full.
- Provide concrete facts that can be cited. Version numbers ("since Go 1.24"), precise descriptions of behaviour, parameter names and links to official documentation are all easier to cite, and easier to verify, than vague descriptions. Give sources when citing external facts; do not write numbers that cannot be checked.
- Use tables and lists for comparisons and steps. Use tables for comparison questions ("the difference between SEO and GEO") and numbered steps for process questions; these structures are very often reused directly in snippets and AI answers.
- Keep it up to date and show the dates. Technical content goes out of date. Show the publication and update dates on the page, and update
dateModifiedand the sitemap'slastmodtogether when the content is revised.
Figure: Content must pass through crawling, rendering and indexing in order before it has any chance of being ranked as a result, extracted as an answer or cited in a generative answer; if any stage fails, nothing after it happens.
Another frequently mentioned concept is E-E-A-T: Experience, Expertise, Authoritativeness and Trustworthiness. It comes from the quality rater guidelines Google gives its human raters, describing the characteristics of high-quality content, and Google has explained that it is not a single ranking factor you can set directly. For technical content, the practical steps include: clearly showing the author and an author page, explaining what the content is based on (official documentation, specifications, runnable example code), noting updates when you correct mistakes, and providing contact details or a way to report problems. Runnable example code is itself a strong trust signal, which is one of the reasons this series insists that every example compiles.
Step 7: llms.txt and robots.txt rules for AI crawlers
llms.txt is a proposal made in 2024: put a Markdown file at the site root that uses a short description and a list of links to tell language models what important content the site has and which pages to read first, sometimes alongside plain-text or Markdown versions of each page. For an API documentation site the idea is intuitive: give AI a concise table of contents.
But be clear about where it stands: llms.txt is a proposal, not a standard. No standards body has adopted it, AI services have not broadly committed to reading it, and Google's public position is that its search and AI features do not use llms.txt. If you want to provide one, the cost is low, and it can serve as a convenient table of contents for developer tools and systems willing to read it; but do not expect it to affect search rankings or AI summaries, and do not put content that belongs on proper pages only in this file.
# Go Microservices Series
> A series of articles from Go fundamentals to running in production, using an online shop's order service as the example and splitting it step by step into services such as order, payment and inventory.
## Articles
- [context: Cancellation, Timeouts and Passing Data](https://docs.example.com/articles/go-context/): cancellation signals, timeouts and request-scoped data
- [Observability: Logs, Metrics and Tracing](https://docs.example.com/articles/observability-logs-metrics-tracing/): slog, Prometheus, OpenTelemetry
## API
- [Order API reference](https://docs.example.com/api/orders/): request and response formats for POST /orders and GET /orders/{id}By contrast, robots.txt is a mechanism with a long-standing convention that became RFC 9309 in 2022, and the major search engines and AI companies have all published the names of their crawlers (User-Agent tokens). This lets you decide separately whether to be indexed by search engines, whether to be used for AI model training, and whether to appear in AI search answers. Common tokens include:
| Token | Owner | Purpose (according to each company's public documentation) |
|---|---|---|
Googlebot | Search indexing; the AI Overviews in Google Search also rely on it | |
Google-Extended | Not a separate crawler, but a control over whether content may be used for training and grounding of models such as Gemini; does not affect search rankings | |
GPTBot | OpenAI | Model training |
OAI-SearchBot | OpenAI | Indexing for ChatGPT's search feature |
ClaudeBot | Anthropic | Model training |
PerplexityBot | Perplexity | Indexing for Perplexity search |
CCBot | Common Crawl | A public web dataset, often used for training |
Bingbot | Microsoft | Bing search indexing; Copilot's search results are also built on it |
A configuration that "welcomes search and citation in AI search, but does not offer content for model training" might look like this:
# Search engines: allowed
User-agent: Googlebot
User-agent: Bingbot
Allow: /
# AI search and citation: allowed
User-agent: OAI-SearchBot
User-agent: PerplexityBot
Allow: /
# Model training: not allowed
User-agent: GPTBot
User-agent: ClaudeBot
User-agent: CCBot
User-agent: Google-Extended
Disallow: /
# Other crawlers: allow public content, exclude internal paths
User-agent: *
Disallow: /admin/
Disallow: /debug/
Sitemap: https://docs.example.com/sitemap.xmlA few things to watch: robots.txt is a "request", not access control, and whether it is obeyed is up to the crawler itself; for some fetchers triggered in real time by a user (for example when a user pastes a URL into a conversation), the documentation may say robots.txt rules do not fully apply. Things that truly must not be public (such as the /debug/pprof/ mentioned in “Performance Tuning in Go: pprof and Benchmarks”) must be protected by the network and authentication, not written into robots.txt, which would actually tell everyone where they are. Also, crawler names and purposes are added and changed over time, so check each company's latest official documentation before configuring. Finally, Disallow only prevents crawling and does not guarantee a page will not be indexed; to make sure a page does not appear in search results, allow crawling and add noindex to the page.
Step 8: Page speed, Core Web Vitals and measurement
Core Web Vitals are three metrics Google uses to measure user experience, and part of its page experience evaluation. The "good" thresholds Google has published are:
| Metric | What it measures | Good threshold |
|---|---|---|
| LCP (Largest Contentful Paint) | How quickly the main content appears | 2.5 s or less |
| INP (Interaction to Next Paint) | How quickly the page responds to interaction (replaced FID in 2024) | 200 ms or less |
| CLS (Cumulative Layout Shift) | Whether the layout jumps around unexpectedly | 0.1 or less |
The thresholds are assessed at the 75th percentile of real-user data. For technical articles and documentation pages, the common improvements are: server-side rendering so the body text is in the HTML directly, specifying width and height on images to avoid layout shifts, reducing the JavaScript loaded on the first page, and making good use of a CDN to cache static assets. If the documentation site is served by a Go service, the RED metrics from “Observability in Go: Logs, Metrics and Tracing” apply just the same: when time to first byte (TTFB) is too slow, no amount of front-end optimisation can win it back. Page speed is rarely the deciding ranking factor, but slow pages make users leave, and make crawlers fetch less in the same amount of time.
Finally, once you have done all this you need to be able to measure it, or you cannot tell what worked:
- Google Search Console: index coverage (which pages are indexed and, if not, why), search performance (queries, impressions, clicks, average position), the Core Web Vitals report, and structured data errors. Impressions and clicks from AI features in Google Search are counted in the web search performance data and currently cannot be fully separated out.
- Bing Webmaster Tools: Bing's indexing and performance data; you can submit sitemaps, and it supports the IndexNow protocol so that Bing and other search engines learn about URL updates immediately. Because several AI services use Bing's search results, this data is well worth watching too.
- Referral traffic from AI assistants: in your web analytics tool, look at visits whose referrer is a domain such as ChatGPT, Perplexity, Gemini or Copilot; some services also add a
utm_sourceparameter to links. This is one of the few ways at present to observe GEO results directly, but it is incomplete: with many AI answers, users read and leave without ever clicking. - Server logs: count each crawler's fetch frequency and status codes from the access logs by User-Agent, to confirm they are getting 200 and not error pages. Note that User-Agents can be forged, so important judgements should be verified against the IP ranges each company publishes or by reverse DNS lookup.
- Regular manual checks: put a few target questions to each AI service and record whether you are cited and whether the citation is correct. These results may differ every time, so treat them only as a reference for trends.
Common pitfalls
- Chasing new terms and ignoring the basics. When pages cannot be fetched, cannot be rendered or are not indexed, no AEO or GEO technique has any effect.
- Content that exists only in JavaScript. Client-side rendered pages are blank to many crawlers. Use server-side rendering or static generation for content pages.
- Structured data that does not match the visible content. Marking up questions, answers or information that do not exist on the page may be treated as a guideline violation.
- Expecting FAQPage to always produce expanded Q&A results. These rich results have been heavily restricted; the markup still has descriptive value, but do not make it your main goal.
- Treating llms.txt as a standard. It is a proposal, and the major search engines do not use it. You can provide one, but do not stake your resources on it.
- Using robots.txt to hide sensitive paths. robots.txt is a public file and only works on well-behaved crawlers. Confidential content needs authentication and network isolation.
- Blocking search engines by mistake. A WAF, bot protection or an overly broad
Disallowrule can make an entire site disappear from search results. After every change, confirm with Search Console's URL Inspection tool. - Inconsistent URL forms across canonical, sitemap and internal links. Trailing slash or not,
wwwor not: each splits the signals. - Writing numbers and claims that cannot be verified. AI systems and readers both place more and more weight on sources; exaggerated or unsourced numbers damage credibility.
- Faking
lastmodand dates. Changing the date to today on every build will, over time, make search engines ignore the signal.
Key takeaways
- SEO gets pages crawled, indexed and ranked; AEO makes content the direct answer; GEO gets generative AI to cite you; AIO means different things to different people, so say which one you mean.
- All four share the same foundation: crawlable, renderable, indexable, with clear and trustworthy content. Get the foundation right first, then worry about the rest.
- Use server-side rendering or static generation for content pages, return honest status codes, and use ordinary
<a href>for internal links. - The sitemap's
lastmodmust be truthful; canonical URLs, the sitemap and internal links should use the same URL form; every page needs its own title and description. - Mark up Article / TechArticle, Person, FAQPage and BreadcrumbList with JSON-LD, with content that matches the page.
- Question-shaped headings, the answer first, paragraphs that stand on their own, and verifiable facts with sources are a way of writing that works for readers, answer engines and AI alike.
- llms.txt is a proposal, not a standard; robots.txt can distinguish search, AI search and model training by crawler name, but it is not access control.
- Measure results with Search Console, Bing Webmaster Tools, AI referral traffic and server logs, and accept that GEO is currently hard to measure completely.
Series wrap-up
This series started from an online shop's order service and went all the way to a microservice system that can go live and be operated:
- Part 1, Go foundations: “Go Project Layout and Go Modules”, error handling, concurrency patterns and context, building the fundamentals of writing good Go.
- Part 2, Writing a service: starting from “net/http and Middleware in Go”, through layered architecture and dependency injection, database/sql and transactions, to testing, turning the order service into a single service that is clearly structured and testable.
- Part 3, Splitting into microservices: starting from “When to Split: Service Boundaries and Decomposition Strategies”, using gRPC, an API gateway, service discovery and load balancing to split the system into
api-gateway,order,paymentandinventory. - Part 4, Reliability: “Timeouts, Retries and Circuit Breakers”, idempotency and distributed locks, message queues and Sagas / the Outbox pattern, so that distributed services stay correct when things fail.
- Part 5, Going live and operating: “Observability in Go: Logs, Metrics and Tracing”, configuration and graceful shutdown, containerising a single service and deploying it on Kubernetes, and performance tuning.
- Part 6, Real-world deployment: “Deploying a Whole Microservice System with Docker Compose” and “Deploying a Microservice System on Kubernetes”, actually running the whole system, then “From Monolith to Microservices: Evolving the Architecture at 100K, 1M and 10M Scale” to see how the system grows with scale, then “Adding Indexes Safely: Indexing Large Tables Without an Outage” and “Hot and Cold Data, Sharding and Splitting Databases: What to Do When the Data Grows” handle the data once it has grown.
- Part 7, Real-world pitfalls: “Concurrency Pitfalls: From Data Races to Overselling”, payment pitfalls, “Preventing Duplicate Payments and Handling Payment Incidents: From the Button to the Provider, and How to Stop the Bleeding”, “Reconciliation: Matching Payment Provider Statements Reliably” and handling money in Go, covering the places where things most often go wrong.
- Part 8, Security and working with AI: “Microservice Security: Authentication, Authorisation, Secrets and Supply Chain”, and how to bring AI into development, connect it to the team's review and CI process, have it help with deployment and troubleshooting, debug within a project, run security checks, and finally connect it to the project management tool OpenProject through MCP.
- Part 9, RAG and tools: “Building a RAG Pipeline in Go: Chunking, Vector Search and Tool Calling” has the model look up the team's documents before answering, and “Writing a Claude Code Skill That Cites Its Sources” then requires a source for every claim.
- Bonus: this very article, about getting the documentation and articles you write found by people and AI.
Each part builds on the one before: without solid Go fundamentals, services will not be stable; without a clear single service, splitting only amplifies the chaos; without reliability design, a distributed system breaks when failures happen; without observability and deployment capability, you cannot see problems when they happen, let alone fix them. I hope this series can serve as a map that shows you where to go next in your own projects.