> ## Documentation Index
> Fetch the complete documentation index at: https://learn.mintlify.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Keep content agent-friendly over time

> Agent-friendly content degrades without attention, just like any other content quality. Here's what to watch and when.

export const Quiz = ({question, answers, correctFeedback, incorrectFeedback}) => {
  const [selected, setSelected] = React.useState(null);
  const [checked, setChecked] = React.useState(false);
  const quizId = React.useId();
  const isCorrect = checked && answers[selected]?.correct;
  const reset = () => {
    setSelected(null);
    setChecked(false);
  };
  return <div className={"quiz-container" + (checked ? " quiz-checked" : "")}>
      <Badge color="green">Quiz</Badge>
      <p className="quiz-question" id={quizId + "-question"}>{question}</p>
      <div className="quiz-options" role="radiogroup" aria-labelledby={quizId + "-question"} aria-disabled={checked}>
        {answers.map((answer, i) => <label key={i} className={["quiz-option", !checked && selected === i ? "quiz-option-selected" : "", checked && answer.correct ? "quiz-option-correct" : "", checked && selected === i && !answer.correct ? "quiz-option-incorrect" : ""].filter(Boolean).join(" ")}>
            <input type="radio" name={"quiz-" + quizId} checked={selected === i} onChange={() => !checked && setSelected(i)} disabled={checked} />
            <span className="quiz-radio" />
            <span className="quiz-option-label">{answer.text}</span>
          </label>)}
      </div>
      {checked && <div className={"quiz-feedback " + (isCorrect ? "quiz-feedback-correct" : "quiz-feedback-incorrect")} role="status" aria-live="polite" aria-atomic="true">
          <span className="quiz-feedback-icon">{isCorrect ? "✓" : "✗"}</span>
          {isCorrect ? correctFeedback : incorrectFeedback}
        </div>}
      <div className="quiz-actions">
        {!checked ? <button className="quiz-btn quiz-btn-check" type="button" onClick={() => selected !== null && setChecked(true)} disabled={selected === null}>
            Check answer
          </button> : <button className="quiz-btn quiz-btn-reset" type="button" onClick={reset}>
            Try again
          </button>}
      </div>
    </div>;
};

<iframe className="w-full aspect-video rounded-xl" src="https://www.youtube.com/embed/bShYBXXl36Q" title="Keep content agent-friendly over time" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen />

Agent-friendliness requires maintenance. As your product changes and content accumulates, your content may stop being agent-friendly. Keeping it solid requires adding a few checks to the maintenance rhythms you should already have.

## Use your agent as a feedback loop

For the most direct signal about whether your content is agent-friendly, ask your preferred agent questions about your content. If it can't answer a question well, that's probably a content problem.

Review agent responses regularly. Look for:

* **Questions it can't answer**: Relevant pages might have vague titles or descriptions. Terminology in your content may be inconsistent with the terminology in the question.
* **Questions it answers incorrectly**: Usually means a page is mixing topics, using ambiguous language, or relying on context the assistant doesn't have.
* **Questions it answers with outdated information**: A page wasn't updated when the product changed.

These conversations show you what users are trying to do and where your content may fall short. If you have access to how your users interact with your content via agents, this is some of the best data you can get. It shows real user intent and what they want to know about your product.

## When the product changes

Documentation stops being agent-friendly the same way it stops being accurate: it was right once and then wasn't updated. Agents don't know when content is stale so they present it with the same confidence as current information.

When a product changes or you release a new feature:

* Update the relevant pages before or alongside the release, not after
* Check whether terminology has changed. If a feature was renamed, find every page that uses the old name and update it
* Update your `CLAUDE.md` and `llms.txt` if the change affects what's important to surface or how to refer to things

## Audit for terminology drift

Terminology consistency is hard to maintain as a team grows and different people contribute to content. Run a periodic audit:

1. List the canonical terms for your most important concepts in a shared style guide
2. Search your content for synonyms and variants
3. Update any pages using non-canonical terms

An agent can help: give it your list of terminology and ask it to scan your content for inconsistencies.

Add new terms to your `CLAUDE.md` or Cursor rules file as your product grows. Define the name before contributors start writing about a new feature.

## Check new pages are self-contained

Remember that every page needs to function as a standalone document. They need to be self-contained so that an agent (or human) can start on any page of your site and understand the content.

Self-containment is the difficult to maintain because the problem is hard to spot while you're writing. You have all the context so you may not notice that a page requires information that's only available on another page.

Add a self-containment check to your review process for new pages:

* Does this page assume the reader has read any other page?
* Does it use terms that are only defined elsewhere?
* If a reader arrived here from an agent's response, would they have enough context to act on what's here?

## Keep `llms.txt` current

Your `llms.txt` is a snapshot of your entire site. Review it whenever you do a significant content update:

* Are there new pages that should be added?
* Is there content that's been deprecated and should be removed?
* Are descriptions still accurate?

## A maintenance rhythm

* **With every product release**: Update affected pages, check for terminology changes, review `CLAUDE.md` and `llms.txt` if relevant
* **Monthly**: Review agent conversations for patterns like unanswered questions, wrong answers, or outdated information
* **Quarterly**: Audit for terminology drift; review `llms.txt` to reflect new or removed content; check that high-traffic pages are self-contained

<Quiz
  question="An agent starts giving wrong answers about a feature that was recently renamed in your product. What's the most likely cause, and what should you fix?"
  answers={[
{ text: "The agent's underlying model is out of date and needs to be retrained", correct: false },
{ text: "Pages still use the old name, so the agent is working from outdated terminology", correct: true },
{ text: "The agent can't handle feature renames and needs manual reconfiguration", correct: false },
{ text: "Users probably just asked about the old name, so the agent is answering based on the old information", correct: false },
]}
  correctFeedback="Right. The agent answers based on your content. If your pages still use the old name, the agent uses the old name too. Update the pages, check your `CLAUDE.md` terminology section, and review your `llms.txt` if the feature was listed there."
  incorrectFeedback="The agent isn't the problem and neither are your users. If pages still use the old feature name, that's what the agent works from. The fix is updating the pages and your `CLAUDE.md` terminology section so future edits use the correct term."
/>

That's the end of the course. You've covered what makes content agent-friendly, the writing and structural habits that make it reliable context for agents, the configuration files that give agents the information they need, and how to keep all of it accurate as your product evolves. The same investment that makes your content useful to agents makes it better for every human who reads it too.

## Go deeper

* [Why agent-friendliness matters](https://afdocs.dev/why-agent-friendliness-matters.html) — An overview of how agents access documentation and why the highest-impact fixes are often configuration changes, not rewrites.
* [The Agent-Friendly Documentation Spec](https://agentdocsspec.com/) — A spec that defines 22 checks for evaluating the agent-friendliness of your documentation.

## Continue learning

* [Structure docs that scale](/courses/structure-docs/overview) — Content types, navigation design, and keeping documentation accurate as your product grows
* [Git and GitHub for docs teams](/courses/git-github/overview) — Version control, branching, and collaboration workflows for documentation
* [Mintlify components](/courses/components/overview) — How to use Mintlify's components to structure and format documentation effectively