---
title: Recency and Authority — Two Fields AI Uses to Trust You
description: Before quoting your article, AI runs two checks — is it fresh, and who wrote it. Both ride on machine-readable signals. Here's the canonical setup.
date: 2026-05-07
tags: [aeo, ai, structured-data, jsonld, nextjs]
---

An AI accepts two judgments before it ever quotes you. First — *is this still current?* Second — *who actually wrote this?* Both happen in fractions of a second, both ride on machine-readable signals you either supplied or didn't.

Here's what's actually happening under the hood of the citation pipeline — and where you fit in it.

## 1. Two checkpoints before the quote

When an LLM composes an answer and is looking for sources to cite, it runs candidates through two filters:

- **Recency check** — is the information current? A 2019 article on the Next.js App Router gets dropped instantly.
- **Authority check** — does the author have weight in this niche? An anonymous Medium post and a senior engineer's post are very far from the same thing for weighted ranking.

No signal — no trust. The AI doesn't guess. It reads what you gave it.

## 2. `datePublished` and `author` — the canonical fields

Inside the `Article` Schema.org type, these two fields carry the load. Here's the canonical pattern for embedding the JSON-LD via a `<script>` block in a Next.js server component:

```tsx title="app/blog/[slug]/page.tsx"
import React from 'react';

interface PageProps {
  params: Promise<{ slug: string }>;
}

export default async function BlogPostPage({ params }: PageProps) {
  const { slug } = await params;

  const jsonLd = {
    "@context": "https://schema.org",
    "@type": "Article",
    "headline": "Recency and Authority in AI Citations",
    "datePublished": "2026-05-07T08:00:00Z",
    "dateModified": "2026-05-07T08:00:00Z",
    "author": {
      "@type": "Person",
      "name": "Oleksii Turovskyi",
      "url": "https://alexturik.com",
      "sameAs": [
        "https://github.com/turovskiy",
        "https://linkedin.com/in/alexturik",
        "https://x.com/alexturik"
      ]
    }
  };

  return (
    <article className="max-w-3xl mx-auto py-10 px-4">
      <script
        type="application/ld+json"
        dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd) }}
      />
      <header className="mb-8 border-b pb-4">
        <h1 className="text-4xl font-bold text-gray-900">
          Recency and Authority in AI Citations
        </h1>
        <time dateTime="2026-05-07T08:00:00Z" className="text-sm text-gray-500 mt-2 block">
          May 7, 2026
        </time>
      </header>
      <div className="prose prose-blue lg:prose-lg">
        <p>Article body starts here…</p>
      </div>
    </article>
  );
}
```

Perplexity, ChatGPT browse, Google AI Overviews, Claude search — they all look at this structure first. Long before they start parsing your HTML.

## 3. The "1 hour ago" badge tells machines nothing

This is where most sites quietly fail. You see "published an hour ago" on the rendered page and assume the date is there. To machines, it isn't.

A text badge is for human eyes only. The crawler ignores it, because the string `"1 hour ago"` cannot be safely resolved to an exact timestamp without deep context. What an algorithm actually needs:

1. **Minimum** — a semantic `<time datetime="2026-05-07T08:00:00Z">May 7, 2026</time>` in the HTML.
2. **Better** — a `datePublished` field in JSON-LD.
3. **Gold standard** — both, in HTML *and* JSON-LD. Duplicating the data here is a feature, not a bug.

## 4. Author is not a string

This is the single most common mistake. People write `"author": "Oleksii Turovskyi"` and move on. Technically valid. Authority — zero.

The right structure is a `Person` object with an identity graph through the `sameAs` array. `sameAs` is the glue that fuses you to your reputation across other ecosystems.

A GitHub account with a commit history, a LinkedIn with relevant experience, a Twitter with expert activity — the AI sees this whole graph and builds a model: *who you are, what you're an expert in, whether it's worth quoting you specifically in this knowledge vertical.* Without `sameAs` you're a text string. With it — a person with a reputation footprint.

## 5. Backup via meta tags

There are situations where embedding JSON-LD painlessly isn't an option. An old WordPress without access to `header.php`. A legacy build. A Jamstack with a stale theme. That's when meta tags in `<head>` step in. Second-tier signal, but AI crawlers do read them.

```html
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Recency and Authority in AI Citations</title>

  <meta property="article:published_time" content="2026-05-07T08:00:00Z">
  <meta property="article:modified_time" content="2026-05-07T08:00:00Z">
  <meta name="author" content="Oleksii Turovskyi">
</head>
<body>
  <article>
    <h1>Recency and Authority in AI Citations</h1>
  </article>
</body>
</html>
```

This is not a full replacement for the `sameAs` graph. But it's much better than naked HTML with no signal at all, and definitely better than leaving your authority an open question for a hallucinating model.

## 6. `dateModified` — the unsung hero

This one gets overlooked all the time. You update an old article — add fresh benchmarks, rewrite a section on hooks, fix outdated CLI commands. Without `dateModified`, AI sees the article as stale based on the original `datePublished` from 2023. No citation.

Add `dateModified` and the recency check passes. The article becomes relevant again. Updating content without updating the markup is a guaranteed lost citation. This is one of the cheapest wins in the entire AEO stack.

## 7. The most common formatting mistake

```text
"datePublished": "2026/05/07"          ✗ invalid
"datePublished": "May 7, 2026"         ✗ invalid
"datePublished": "07.05.2026"          ✗ invalid
"datePublished": "2026-05-07T08:00:00Z" ✓ ISO 8601, works
```

Schema.org requires **ISO 8601**. No exceptions. Plug your URL into [validator.schema.org](https://validator.schema.org/) after every template change — it catches this in seconds.

## 8. Reusable author schema

Wrap the block once and you get authority signals on every publication, forever:

```ts title="src/lib/schema/author.ts"
export function getAuthorSchema() {
  return {
    "@type": "Person",
    "name": "Oleksii Turovskyi",
    "url": "https://alexturik.com",
    "sameAs": [
      "https://github.com/turovskiy",
      "https://linkedin.com/in/alexturik",
      "https://x.com/alexturik"
    ]
  };
}
```

Call it inside every JSON-LD generator. Write it once — pays back across every post.

---

**Auditing your own site?**

Open the Schema Markup Validator on a recently-published post. If `datePublished` is missing, malformed, or the author is a bare string — your recency and authority checks are silently failing on every AI citation pipeline that visits your domain.

Follow me on [LinkedIn](https://linkedin.com/in/alexturik) for more on AEO architecture. For a structured-data audit or schema implementation on your platform, [get in touch](mailto:alexturik@gmail.com).