The seven layers
The methodology consists of seven layers. They are not independent improvements; each one rests on the previous, and the whole produces more than the sum of its parts.
1. Semantic HTML: the skeleton machines read
Generic div and span containers carry no semantic meaning; an AI system cannot tell whether a div is navigation, main content or a footer. An AI-First page is therefore built with meaningful HTML5 tags: standalone content lives in article, thematic groups in section, navigation in nav and the core content in main.
In practice
Every page has exactly one main and one h1, and the heading hierarchy descends from H1 to H2 to H3 without skipping levels. That hierarchy is a table of contents for machines: an engine derives what each part of the page covers from the headings.
2. Schema.org structured data: entity definition in JSON-LD
Visible content explains to humans; structured data defines for machines. Every page carries Schema.org markup in JSON-LD: Organization defines the company as an entity, Service ties each offering to its provider, FAQPage presents question and answer pairs in a form engines can quote, and BreadcrumbList states where the page sits in the site hierarchy.
In practice
One principle is non-negotiable: the schema mirrors the visible content exactly. Nothing that is absent from the page is written into the schema, because markup that contradicts what is visible weakens the trust signal instead of strengthening it.
3. llms.txt: the site's machine-readable self-description
robots.txt tells a crawler what it may crawl; llms.txt tells it what the site is. Published at /llms.txt in the root directory, this plain text file is a compact, machine-readable self-description of the site prepared for AI systems.
In practice
The file consists of four sections: a one-sentence definition of the company, a short about block, an annotated link list of the main sections and services, and contact details. The aim is for an engine to pick up the correct frame from one file before it walks the site page by page.
4. Bot optimization: opening the doors deliberately
However good the content is, an engine whose crawler cannot reach the page cannot cite it. In robots.txt, access for AI crawlers such as GPTBot (ChatGPT), ClaudeBot (Claude) and Google-Extended (Gemini) is defined deliberately; the XML sitemap is kept current, and important pages stay reachable within a few clicks of the homepage.
In practice
The second condition is renderability: content is not hidden behind JavaScript. The core text of a page arrives from the server as ready HTML; content that only appears after JavaScript runs in the browser simply does not exist for many bots.
5. Performance: Core Web Vitals and server-side generation
Speed is a quality signal for humans and machines alike. The methodology targets the public Core Web Vitals thresholds: LCP (Largest Contentful Paint) under 2.5 seconds, INP (Interaction to Next Paint) under 200 milliseconds and CLS (Cumulative Layout Shift) under 0.1. These thresholds are not our invention; they are public standard values.
In practice
Pages are produced with server-side rendering (SSR) or prepared ahead of time with incremental static regeneration (ISR); images are served in modern formats, at the right size and with reserved space. Content reaches both the visitor and the crawler without waiting.
6. E-E-A-T: experience, expertise, authoritativeness, trust
AI engines care about who the source is. The methodology makes E-E-A-T signals part of the structure: content is tied to real author profiles, first-hand experience is described, and every claim is kept verifiable.
In practice
The rule of this layer defines the methodology's character: no unmeasured number is ever written. Avoiding invented percentages, fictional clients and guarantee language is not only an ethical choice but a technical requirement, because an unverifiable claim weakens the trust signal.
7. Measurement: baseline and delta
The final layer is in place from day one: before launch, a baseline of the current state is measured. Search Console records visibility and click data, GA4 records traffic sources and user behavior, and the AI Authority Score records the starting value of brand visibility across the four engines (ChatGPT, Gemini, Claude, DeepSeek).
In practice
After launch, the same metrics are tracked with the same method and the delta is reported. The conversation is not about a feeling that the site got better; it is about measured change against the baseline, with measurements and forecasts marked separately in every report.
The methodology in practice: how a page is born
So the layers do not stay abstract: a new service page reaches publication through this flow.
- 1
Content model
The questions the page must answer are listed first; the heading hierarchy is built from those questions. The audience's own language and the concepts they search for appear verbatim in the headings.
- 2
Schema
Schema.org markup matching the page type is added: Service and FAQPage for a service page, Article and BreadcrumbList for guide content. The schema is compared line by line against the visible content.
- 3
Internal linking
The page is wired into the site hierarchy: it receives a link from its parent service page and links out to related blog and knowledge base content. No page is published as an orphan.
- 4
Publication checklist
A pre-launch checklist runs: one h1, valid JSON-LD, complete meta fields, robots.txt and sitemap registration, Core Web Vitals measurement, renderability test.
- 5
Measurement
The page goes live with its baseline measured; Search Console, GA4 and AI Authority Score data are tracked, and the delta feeds the next content decisions.
Frequently asked questions
Which projects is the AI-First methodology suited to?
It suits any project that wants to be found through its content, including new builds, corporate relaunches and e-commerce. Wherever being searched for and being cited matter, the layers are the same; only their weighting changes. On a small brochure site, schema and llms.txt are a comparatively narrow job; on a content-heavy platform, the measurement and content model layers move to the front.
Can it be applied gradually to an existing site?
Yes. The methodology is most comfortable in a greenfield build, but the layers can be applied to an existing site step by step. The typical order: first the baseline measurement, then low-risk additions such as robots.txt and llms.txt, then schema markup, and finally template-level changes for semantic structure and performance. Each step creates value on its own, and the decision for the next step is made on measurement.
Which frameworks do you work with?
Tool choice comes after need. The technical precondition of the methodology is a modern stack capable of server-side rendering (SSR) or incremental static regeneration (ISR); Next.js, which this site is also built with, serves that need well, but it is not the only valid answer. If your existing infrastructure can produce renderable HTML, the methodology can be applied on top of it.
Is llms.txt actually read?
The honest answer: crawler behavior is evolving, and how often a given engine reads the file varies from engine to engine. llms.txt is a reasonable investment despite that uncertainty, because its cost is low, it carries no downside risk, and it is a signal that is becoming standardized. We prefer being the party whose file is ready over being caught unprepared when engines start reading it consistently.
When do results become visible?
We do not give a fixed timeframe, because the outcome depends on your industry, competition, content volume and starting point. Instead, a baseline is measured before launch and the same metrics are tracked regularly afterwards: Search Console visibility, GA4 traffic and brand visibility across the four engines. What gets discussed is not a guess; it is the measured delta against the baseline.