diff --git a/.eslintrc.js b/.eslintrc.js
index 7d6108d36b..a5e9976e13 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -148,6 +148,6 @@ module.exports = {
       rules: {
         '@typescript-eslint/no-non-null-assertion': 'off',
       }
-    }
+    },
   ],
 }
diff --git a/DEV_DOCS.md b/DEV_DOCS.md
index 4232cb2ff9..9a667d545b 100644
--- a/DEV_DOCS.md
+++ b/DEV_DOCS.md
@@ -8,6 +8,7 @@ Canonical reference for everyone working on the HyperFormula source code: mainta
 - **[Test suite](test/README.md)** — smoke tests and how to attach the private test suite
 - **[Public docs portal](https://hyperformula.handsontable.com/docs)** — main documentation
 - **[Docs README](docs/README.md)** — how to run the docs portal locally
+- **[Docs content guide](DOCS_CONTENT_GUIDE.md)** — how to create and edit docs content
 - **[Changelog](CHANGELOG.md)**
 - **[Pull request template](.github/pull_request_template.md)**
 
@@ -90,6 +91,10 @@ A single pull request should contain an atomic self-contained functional change
 - All changes to the production code must be covered by automatic tests kept in the `test/` directory.
 - Each test case must be very simple and focused on a single assertion. Don't use loops, conditionals, or other control flow statements in test cases.
 
+## Documentation
+
+- Follow the [documentation content guide](DOCS_CONTENT_GUIDE.md) when creating or editing docs (writing style, language, and how to structure guides).
+
 ## How to add a new function
 
 Adding a built-in function is similar to adding a [custom function](docs/guide/custom-functions.md), so that guide is a useful reference for the function-implementation patterns (argument metadata, return types, array handling). The built-in flow on top of that is:
diff --git a/DOCS_CONTENT_GUIDE.md b/DOCS_CONTENT_GUIDE.md
new file mode 100644
index 0000000000..899c402fe8
--- /dev/null
+++ b/DOCS_CONTENT_GUIDE.md
@@ -0,0 +1,262 @@
+# Documentation content guide
+
+## The one principle
+
+**Every page and every section is retrieved and read in isolation, out of order,
+by a reader with zero prior context.** RAG systems pull one chunk at a time; a
+search result or an AI answer may show only part of a page. So:
+
+> If the answer to a question is not present on a single page, in plain text, in a
+> self-contained place — it effectively does not exist.
+
+Write so any one page fully answers one real question. Everything below serves this.
+
+The good news: this is just *good documentation*. The same clarity that helps the AI
+helps humans and search. You are not gaming an algorithm — you are writing clearly.
+
+---
+
+
+
+## Project context
+
+- **Product:** HyperFormula — an open-source, headless spreadsheet and formula
+engine written in TypeScript. It parses and evaluates ~400 Excel/Google
+Sheets–compatible functions. It has **no UI**. It runs in the browser or Node.js.
+- **Sibling product:** Handsontable (the data grid). HyperFormula is maintained by
+the same team but is a **separate product** — do not blur the two.
+- **Docs source:** Markdown in the `docs/` folder of the `handsontable/hyperformula`
+repo. Guide pages live at `docs/guide/<slug>.md`; the landing page is
+`docs/index.md`; API reference under `docs/api/` is **generated from source code
+TSDoc — do not hand-edit it**, improve the code comments instead.
+- **Toolchain:** VuePress 1.9.10 (static site generator). Pages support YAML
+frontmatter, `::: tip / warning / danger` containers, and fenced code blocks.
+- **Runnable demos:** hosted on StackBlitz (`handsontable/hyperformula-demos`),
+linked per version branch (e.g. `3.3.x`).
+
+---
+
+
+
+## What to write (coverage & gap prioritization)
+
+Optimization cannot recover a page that doesn't exist. Coverage comes first.
+
+1. **Write the "obvious" pages.** The journeys teams skip because they feel too
+  basic are the ones users ask first: installation (client- and server-side), basic
+   usage, configuration options, the **license key** (a top gotcha), a first working
+   formula, reading/writing cell values, named expressions, custom functions.
+2. **Prioritize by real demand, not intuition.** Rank what to write next using:
+  - Support tickets and GitHub issues from the last quarter — each recurring one
+   should map to a single findable page. If it doesn't, that's your next page.
+  - The docs AI assistant / search logs — repeated questions signal a missing or
+  hard-to-find page; questions that span sections signal an organization problem;
+  requests for examples signal thin practical guidance.
+  - Start with the boring, high-traffic paths before advanced/edge topics.
+3. **Prefer less, but better.** Quality beats coverage for retrieval. Delete or
+  archive outdated tutorials, deprecated-feature guides, near-duplicate pages, and
+   thin placeholder stubs. Stale content competes with correct content and the model
+   cannot tell which is current.
+4. **Never contradict yourself across pages.** Two pages that disagree are worse than
+  one correct page, because retrieval may surface either. When you add or change a
+   fact, grep the docs for the old statement and fix every occurrence.
+5. **Document errors with their exact text.** Users (and assistants) search by
+  pasting the literal error string. For each common error, use the exact message as
+   a heading, then give the cause and the fix:
+   `### Error: "Named expression 'X' already exists"` → why it happens → how to
+   resolve. Reference HyperFormula's error types (`#REF!`, `#VALUE!`, `#NAME?`, etc.)
+   by their real symbols.
+
+---
+
+
+
+## How to structure a page
+
+Treat **every page as page one.**
+
+1. **Open with scope and prerequisites.** The first lines state what the page covers,
+  which version it applies to, and what the reader must already have done. Example
+   opener: "This guide covers custom functions in HyperFormula. You need HyperFormula
+   installed and a working instance (see Basic usage)."
+2. **Name the subject in the body, not just the title.** Write "HyperFormula's
+  `buildFromArray` method…", not "the `buildFromArray` method…". A retrieved chunk
+   must carry a clear signal of what product/feature it belongs to, because the title
+   and breadcrumb may be stripped away. Don't overdo it — once per section is enough.
+3. **Front-load the essential context**, then the details. A reader who sees only the
+  first chunk should still get the core answer.
+4. **Self-containment beats DRY — resolve the tension deliberately.** RAG wants
+  repetition; engineering instinct wants "don't repeat yourself." For docs content,
+   **self-containment wins**:
+  - Repeat the small essential context a reader needs to act here (e.g. that an
+  instance is created with a `licenseKey`), even if it appears on other pages.
+  - **Link** to another page for *depth* or *related* topics — never make the reader
+  leave this page to understand or complete *this* task.
+  - Rule of thumb: if removing a link would make the current task impossible to
+  finish, that information belongs on the page, not behind the link.
+5. **Author the frontmatter.** Every page gets a specific `title` and a one-sentence
+  `description` that names the concept (this becomes the meta description and helps
+    scoping). Titles describe the *thing*, not the category: "WebSocket configuration"
+    → good; "Configuration" → bad. Give the file a meaningful slug
+    (`custom-functions.md`, not `page3.md`).
+
+---
+
+
+
+## How to structure sections (chunking)
+
+1. **One purpose per section.** Each `##`/`###` answers exactly one question. Don't
+  mix installation, configuration, and troubleshooting under one heading — split
+    them so each chunk retrieves cleanly. Keep procedures ("how to…") separate from
+    reference ("what the options are").
+2. **Keep related facts physically close.** A constraint and its consequence go in
+  the same paragraph or adjacent ones, so chunking can't separate them. Bad: state
+    a limit in section 1 and its handling in section 4. Good: state both together.
+3. **Kill backward references.** Delete "as mentioned above," "now that you've done
+  X," "with everything configured." These break the moment the section is read
+    alone. Replace with the explicit context.
+4. **Use a real heading hierarchy.** `#` once (page title), then `##` → `###`, in
+  order, reflecting true topic structure. Headings are descriptive and specific.
+    Never skip levels or use a heading purely for visual size.
+5. **Never leave long, undivided prose — make it granular.** Break any long stretch
+  of text into smaller, focused pieces under their own `##` or `###` headings. A
+    wall of text buries several distinct answers in one chunk and retrieves poorly.
+    Each subsection should be short enough that its heading accurately describes
+    everything beneath it. If a section runs past a few paragraphs, or starts drifting
+    into a second idea, split it and give the new part its own descriptive H2/H3.
+    Prefer more, well-labeled subsections over fewer long ones.
+6. **Give each variation its own section.** When documenting multiple methods,
+  modes, or versions (e.g. `buildFromArray` vs `buildFromSheets` vs `buildEmpty`),
+    write a labeled section per variation rather than interleaving them.
+
+---
+
+
+
+## Language & terminology
+
+1. **Write plainly.** Aim for a ~6th–7th-grade reading level: short sentences, one
+  idea each. Simple prose reduces both human confusion and AI misinterpretation.
+2. **Use active voice.** "HyperFormula evaluates the formula," not "the formula is
+  evaluated."
+3. **One term per concept, everywhere.** Pick the canonical term and never drift.
+  HyperFormula-specific vocabulary to keep consistent: *instance* (not "object"),
+    *sheet*, *cell address*, *named expression*, *formula*, *custom function*,
+    *config/options object*. Don't alternate "config" / "settings" / "options" for
+    the same thing.
+4. **Keep a glossary and spell out acronyms on first use** on each page — "Abstract
+  Syntax Tree (AST)", "Cyclic Reference (CREF)". Link related glossary terms.
+5. **One language per page.** Write docs in English; do not interleave other natural
+  languages. (This is about prose, not about supporting HyperFormula's 17 formula
+    locales — those are a documented feature.)
+6. **State everything explicitly; assume no prior knowledge.** List prerequisites
+  inside the procedure instead of assuming setup. If a step depends on an external
+    tool or concept, give one line of context or a link. The AI cannot infer what you
+    didn't write.
+
+---
+
+
+
+## Code examples
+
+Code is the primary content of these docs. Models reproduce complete examples well
+and hallucinate the parts you omit.
+
+1. **Make every example complete and runnable.** Include imports, instance creation
+  with the `licenseKey` (a required, commonly-missed step —
+    `HyperFormula.buildEmpty({ licenseKey: 'gpl-v3' })`), the data setup, the call,
+    and how to read the result. No fragments that assume invisible surrounding code.
+2. **Show where code lives when structure matters** — a filename comment
+  (`// src/calc.ts`) or a short file tree for multi-file examples, so the reader can
+    place it correctly.
+3. **Tag every code block with its language** (````javascript`, ````ts`,
+  ````bash`). Never use an untagged fence.
+4. **Use consistent, correct API shapes.** Cell addresses use a fixed property order
+  every time — `{ sheet, row, col }` — don't reorder it between examples. Prefer the
+    real method names (`setCellContents`, `getCellValue`, `addSheet`, `getSheetId`,
+    `addNamedExpression`). When a runnable demo exists, link the StackBlitz for the
+    matching version branch.
+5. **Show the correct way; show a wrong way only when it prevents a frequent
+  mistake.** If you include an anti-pattern, label it clearly ("Don't do this —
+    it throws because…") so it can't be mistaken for a recommendation.
+
+---
+
+
+
+## Visuals, tables & the "why"
+
+1. **Never put information only in an image, diagram, or video.** Assistants can't
+  read pixels reliably. Put the same information in text next to the visual. Add a
+    descriptive caption to every image.
+2. **Write UI/interactive flows as numbered, literal steps** — name the exact method,
+  option, or button and what it does at each step, so the steps stand without the
+    screenshot.
+3. **Keep diagrams simple:** one diagram per concept, readable labels, no vertical
+  text, and represent multi-step workflows as a numbered list *in addition to* any
+    flowchart.
+4. **Tables: simple and self-describing.** Real header rows, one fact per cell, each
+  row understandable on its own. Avoid merged cells or layouts where meaning comes
+    from visual position — convert those to structured lists or sub-sections. If a
+    table is only decorative grouping, use headings instead.
+5. **Explain the "why," not just the "what."** Document intent, design decisions, and
+  when to use a pattern — the context source code alone doesn't convey. Call out
+    edge cases, gotchas, and common mistakes with their resolution (e.g. why
+    `buildEmpty` needs a `licenseKey`, when to use named expressions vs. cell
+    references, precision/rounding caveats).
+
+---
+
+
+
+## VuePress conventions (so your output fits the site)
+
+- Start each page with frontmatter:
+  ```yaml
+  ---
+  title: Custom functions
+  description: Register and use your own functions in HyperFormula.
+  ---
+  ```
+- Use containers for asides: `::: tip`, `::: warning`, `::: danger` … `:::`. Put
+essential steps in the body, not hidden inside a tip.
+- Use **relative links** between guide pages (`./named-expressions.md`) and link to
+API symbols under `/docs/api/`.
+- Leave the auto-generated "Help us improve this page" edit link and sidebar to
+VuePress — don't hand-write navigation.
+- Don't hand-edit `docs/api/**` — it's generated from TSDoc in the source.
+
+---
+
+
+
+
+## Self-review checklist (run before finishing any page)
+
+- [ ] **Stands alone:** a reader who lands here cold, seeing only this page, can
+  ```
+  finish the task without opening another page.
+  ```
+- [ ] **One question per section**, descriptive headings, hierarchy in order.
+- [ ] **No walls of text:** long prose is broken into granular H2/H3 subsections,
+  ```
+  each short enough that its heading covers everything under it.
+  ```
+- [ ] **Product named** in the body; no bare "the library/the method/the grid."
+- [ ] **No backward references** ("as above," "now that you've…").
+- [ ] **Prerequisites stated explicitly**; nothing assumed.
+- [ ] **Terminology consistent** with the canonical terms; acronyms expanded once.
+- [ ] **Every code block** is language-tagged, complete, includes the `licenseKey`,
+  ```
+  and would actually run; cell-address property order is `{ sheet, row, col }`.
+  ```
+- [ ] **No info trapped in images/tables**; visuals have text equivalents and captions.
+- [ ] **Frontmatter** has a specific `title` and a one-sentence `description`.
+- [ ] **No contradiction** with other pages; old facts updated everywhere.
+- [ ] **"Why" is covered:** intent, when-to-use, and known gotchas — not just syntax.
+- [ ] Would an AI assistant quoting *only this page* give a correct, complete answer?
+  ```
+  If not, fix the page.
+  ```
diff --git a/context7.json b/context7.json
new file mode 100644
index 0000000000..b819d18d1e
--- /dev/null
+++ b/context7.json
@@ -0,0 +1,14 @@
+{
+  "$schema": "https://context7.com/schema/context7.json",
+  "projectTitle": "HyperFormula",
+  "description": "Headless, Excel-compatible spreadsheet engine in TypeScript — parses and evaluates ~400 functions in the browser or Node.js. In-process library (no REST API).",
+  "folders": ["docs"],
+  "excludeFolders": ["docs/.vuepress", "docs/api"],
+  "rules": [
+    "HyperFormula is an in-process library, not a REST API — there is no HTTP endpoint or base URL.",
+    "Public API cell addresses are 0-indexed: { sheet, col, row }.",
+    "There is no #CALC! error type.",
+    "EmptyValue is exported as a Symbol, not null/undefined.",
+    "A license key is required when constructing the engine (use 'gpl-v3' for open-source use)."
+  ]
+}
diff --git a/docs/.vuepress/components/CodingAgentWizard.vue b/docs/.vuepress/components/CodingAgentWizard.vue
new file mode 100644
index 0000000000..6eb24284a4
--- /dev/null
+++ b/docs/.vuepress/components/CodingAgentWizard.vue
@@ -0,0 +1,109 @@
+<template>
+  <div class="agent-wizard">
+    <div v-if="!selected" class="agent-wizard__choices">
+      <p class="agent-wizard__prompt">Which coding agent do you use?</p>
+      <button
+        v-for="opt in options"
+        :key="opt.id"
+        class="agent-wizard__choice"
+        type="button"
+        @click="selected = opt.id"
+      >{{ opt.label }}</button>
+    </div>
+
+    <div v-else class="agent-wizard__result">
+      <button class="agent-wizard__back" type="button" @click="reset">&larr; Change</button>
+      <h3>{{ current.label }}</h3>
+      <pre class="agent-wizard__snippet"><code>{{ current.snippet }}</code></pre>
+      <button class="agent-wizard__copy" type="button" @click="copy">{{ copied ? 'Copied!' : 'Copy' }}</button>
+      <p class="agent-wizard__note" v-html="current.note"></p>
+    </div>
+  </div>
+</template>
+
+<script>
+import { copyToClipboard } from './clipboard';
+
+export default {
+  name: 'CodingAgentWizard',
+  data() {
+    return {
+      selected: null,
+      copied: false,
+      options: [
+        {
+          id: 'claude-code',
+          label: 'Claude Code',
+          snippet: '/plugin marketplace add handsontable/handsontable-skills\n/plugin install handsontable-skills@handsontable-skills',
+          note: 'Installs the official <code>hyperformula</code> skill. Claude Code loads it automatically.',
+        },
+        {
+          id: 'cursor',
+          label: 'Cursor',
+          snippet: 'Add to your AGENTS.md / rules file:\nHyperFormula docs (LLM-friendly): https://hyperformula.handsontable.com/docs/llms-full.txt',
+          note: 'Cursor has no Claude-skill installer yet — point it at the full docs corpus instead.',
+        },
+        {
+          id: 'copilot',
+          label: 'GitHub Copilot',
+          snippet: 'Add to .github/copilot-instructions.md:\nReference HyperFormula docs: https://hyperformula.handsontable.com/docs/llms-full.txt',
+          note: 'Copilot reads an instructions file — link it to the corpus so it fetches authoritative docs.',
+        },
+        {
+          id: 'other',
+          label: 'Other / API',
+          snippet: 'curl -s https://hyperformula.handsontable.com/docs/llms-full.txt',
+          note: 'Fetch the full corpus, or upload the skill folder from <code>handsontable/handsontable-skills</code> to the Claude API.',
+        },
+      ],
+    };
+  },
+  computed: {
+    current() {
+      return this.options.find(o => o.id === this.selected) || null;
+    },
+  },
+  methods: {
+    reset() { this.selected = null; this.copied = false; },
+    copy() {
+      if (!this.current) return;
+      copyToClipboard(this.current.snippet).then(() => {
+        this.copied = true;
+        setTimeout(() => { this.copied = false; }, 1500);
+      });
+    },
+  },
+};
+</script>
+
+<style scoped>
+.agent-wizard { border: 1px solid #eaecef; border-radius: 6px; padding: 1rem 1.25rem; margin: 1.5rem 0; }
+.agent-wizard__prompt { font-weight: 600; margin: 0 0 0.75rem; }
+.agent-wizard__choice,
+.agent-wizard__copy,
+.agent-wizard__back {
+  cursor: pointer; border: 1px solid #3eaf7c; background: #fff; color: #3eaf7c;
+  border-radius: 4px; padding: 0.4rem 0.8rem; margin: 0 0.5rem 0.5rem 0; font-size: 0.9rem;
+}
+.agent-wizard__choice:hover,
+.agent-wizard__copy:hover { background: #3eaf7c; color: #fff; }
+.agent-wizard__back { border-color: #ccc; color: #666; }
+/* Match VuePress fenced code blocks ($codeBgColor = #282c34) so the snippet is
+   visually consistent with the rest of the docs' code blocks. */
+.agent-wizard__snippet {
+  background: #282c34;
+  color: #fff;
+  padding: 0.75rem 1rem;
+  border-radius: 6px;
+  overflow-x: auto;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+.agent-wizard__snippet code {
+  color: inherit;
+  background: transparent;
+  font-family: source-code-pro, Menlo, Monaco, Consolas, 'Courier New', monospace;
+  font-size: 0.85rem;
+}
+.agent-wizard__note { font-size: 0.85rem; color: #666; }
+</style>
diff --git a/docs/.vuepress/components/ViewMarkdownLink.vue b/docs/.vuepress/components/ViewMarkdownLink.vue
new file mode 100644
index 0000000000..3a4c62cc5f
--- /dev/null
+++ b/docs/.vuepress/components/ViewMarkdownLink.vue
@@ -0,0 +1,39 @@
+<template>
+  <p v-if="mdUrl" class="view-markdown-link">
+    <a :href="mdUrl">View as Markdown</a>
+  </p>
+</template>
+
+<script>
+export default {
+  name: 'ViewMarkdownLink',
+  computed: {
+    mdUrl() {
+      const p = this.$page && this.$page.path;
+      // The 404 page is excluded from companion generation — no link there.
+      if (!p || p === '/404.html') return null;
+      // `.html` page → sibling `.md`; directory / landing URL (`/`, `/guide/`)
+      // → its `index.md` companion. Both are emitted by the md-companions plugin,
+      // so the link is available on every generated page.
+      if (/\.html$/.test(p)) return this.$withBase(p.replace(/\.html$/, '.md'));
+      if (p.endsWith('/')) return this.$withBase(`${p}index.md`);
+      return null;
+    },
+  },
+};
+</script>
+
+<style lang="stylus" scoped>
+@require '../styles/palette.styl'
+
+.view-markdown-link
+  margin 0 0 1rem
+  font-size 0.85rem
+
+  a
+    color $accentColor
+    text-decoration none
+
+    &:hover
+      text-decoration underline
+</style>
diff --git a/docs/.vuepress/components/clipboard.js b/docs/.vuepress/components/clipboard.js
new file mode 100644
index 0000000000..694b8b1bcc
--- /dev/null
+++ b/docs/.vuepress/components/clipboard.js
@@ -0,0 +1,29 @@
+/**
+ * Copy text to the clipboard, falling back to a hidden `<textarea>` +
+ * `execCommand('copy')` when the async Clipboard API is unavailable (insecure
+ * context / older browsers). Always resolves, so callers can chain a single
+ * `.then()` for their "Copied!" state regardless of which path ran.
+ *
+ * @param {string} text text to place on the clipboard
+ * @returns {Promise<void>}
+ */
+export function copyToClipboard(text) {
+  const fallback = () => {
+    // Never throw: the "always resolves" contract must hold even if the DOM
+    // or execCommand path fails (e.g. detached document, disabled command).
+    try {
+      const el = document.createElement('textarea');
+      el.value = text;
+      el.style.position = 'fixed';
+      el.style.opacity = '0';
+      document.body.appendChild(el);
+      el.select();
+      try { document.execCommand('copy'); } finally { document.body.removeChild(el); }
+    } catch (_) { /* clipboard truly unavailable — nothing more we can do */ }
+  };
+  if (navigator.clipboard && window.isSecureContext) {
+    return navigator.clipboard.writeText(text).catch(fallback);
+  }
+  fallback();
+  return Promise.resolve();
+}
diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index 8971d8f5b6..eb7a3a785e 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -5,6 +5,7 @@ const searchBoxPlugin = require('./plugins/search-box');
 const examples = require('./plugins/examples/examples');
 const HyperFormula = require('../../dist/hyperformula.full');
 const includeCodeSnippet = require('./plugins/markdown-it-include-code-snippet');
+const mdCompanions = require('./plugins/md-companions');
 
 const searchPattern = new RegExp('^/api', 'i');
 
@@ -31,7 +32,6 @@ const DOCS_HOSTNAME = process.env.DOCS_HOSTNAME || buildConfigOverrides.hostname
 module.exports = {
   title: 'HyperFormula (v' + HyperFormula.version + ')',
   description: 'HyperFormula is an open-source, high-performance calculation engine for spreadsheets and web applications.',
-  globalUIComponents: [],
   head: [
     // Import HF (required for the examples)
     [ 'script', { src: 'https://cdn.jsdelivr.net/npm/hyperformula/dist/hyperformula.full.min.js' } ],
@@ -89,6 +89,7 @@ module.exports = {
       exclude: ['/404.html'],
       changefreq: 'weekly'
     }],
+    [mdCompanions, { hostname: DOCS_HOSTNAME }],
     searchBoxPlugin,
     ['container', examples()],
     {
@@ -206,6 +207,7 @@ module.exports = {
             ['/guide/advanced-usage', 'Advanced usage'],
             ['/guide/configuration-options', 'Configuration options'],
             ['/guide/license-key', 'License key'],
+            ['/guide/setup-coding-agent', 'Set up your coding agent'],
           ]
         },
         {
diff --git a/docs/.vuepress/plugins/md-companions/index.js b/docs/.vuepress/plugins/md-companions/index.js
new file mode 100644
index 0000000000..eb14f636aa
--- /dev/null
+++ b/docs/.vuepress/plugins/md-companions/index.js
@@ -0,0 +1,138 @@
+const fs = require('fs');
+const path = require('path');
+const { stripVuePressSyntax } = require('./strip');
+
+/**
+ * Rewrite root-relative Markdown links (`](/guide/…)`, `](/api/…)`) to include
+ * the configured `base` (`/docs/`). VuePress rebases these for the HTML site,
+ * but the raw `.md` companions do not — so without this an agent resolving them
+ * from the site origin lands outside `/docs/` and 404s. Protocol-relative
+ * (`//…`), absolute (`http…`), anchor (`#…`) and relative links are untouched.
+ * @param {string} md stripped markdown
+ * @param {string} base configured base, e.g. '/docs/'
+ * @returns {string}
+ */
+function rebaseRootLinks(md, base) {
+  const prefix = (base || '/').replace(/\/$/, '');
+  if (!prefix) return md;
+  // Fence-aware: never touch link-shaped text inside fenced code blocks.
+  const out = [];
+  let inFence = false;
+  let marker = '';
+  for (const line of md.split('\n')) {
+    const t = line.trim();
+    const fm = t.match(/^(```+|~~~+)/);
+    if (fm && (!inFence || (fm[1][0] === marker[0] && fm[1].length >= marker.length))) {
+      if (!inFence) { inFence = true; marker = fm[1]; } else { inFence = false; }
+      out.push(line);
+      continue;
+    }
+    out.push(inFence ? line : line.replace(/(\]\()\/(?!\/)/g, `$1${prefix}/`));
+  }
+  return out.join('\n');
+}
+
+/**
+ * Resolve every Markdown link in a page to an ABSOLUTE URL, relative to that
+ * page's own URL. Needed only for `llms-full.txt`: it aggregates all pages into
+ * one file at a single URL, so page-relative links (`](basic-usage.md)`,
+ * `](../api/x.md)`) would otherwise resolve against the corpus URL and 404.
+ * Per-page `.md` companions keep relative links (they resolve within the
+ * companion tree). Fence-aware; leaves absolute/protocol/anchor links alone.
+ * @param {string} md
+ * @param {string} pageUrl absolute URL of the page this content came from
+ * @returns {string}
+ */
+function absolutizeLinks(md, pageUrl) {
+  const out = [];
+  let inFence = false;
+  let marker = '';
+  for (const line of md.split('\n')) {
+    const t = line.trim();
+    const fm = t.match(/^(```+|~~~+)/);
+    if (fm && (!inFence || (fm[1][0] === marker[0] && fm[1].length >= marker.length))) {
+      if (!inFence) { inFence = true; marker = fm[1]; } else { inFence = false; }
+      out.push(line);
+      continue;
+    }
+    if (inFence) { out.push(line); continue; }
+    out.push(line.replace(/\]\(([^)\s]+)\)/g, (m, target) => {
+      if (/^(https?:|mailto:|#)/i.test(target) || target.startsWith('//')) return m;
+      try { return `](${new URL(target, pageUrl).href})`; } catch (_) { return m; }
+    }));
+  }
+  return out.join('\n');
+}
+
+/**
+ * VuePress plugin: after build, write a clean `.md` companion next to each
+ * rendered `.html`, plus an aggregate `llms-full.txt`. Respects ctx.outDir
+ * (which already includes the configured base segment).
+ * @param {object} options plugin options
+ * @param {object} ctx VuePress app context
+ */
+module.exports = (options, ctx) => ({
+  name: 'md-companions',
+  async generated() {
+    const hostname = (options && options.hostname) || 'https://hyperformula.handsontable.com';
+    const base = ctx.base || '/';
+    // Include `.html` pages AND clean-URL / section-index pages whose path ends
+    // in `/` (home, directory landings) — otherwise they are silently absent
+    // from the corpus. Skip the 404 page (never a useful companion).
+    const pages = ctx.pages.filter(
+      p => (/\.html$/.test(p.path) || p.path.endsWith('/')) && p.path !== '/404.html'
+    );
+    const corpus = [
+      '# HyperFormula Documentation',
+      '',
+      '> Full documentation corpus for LLM consumption.',
+      '> Each page below is also served as clean Markdown — append `.md` to a docs page URL.',
+      '',
+    ];
+
+    for (const page of pages) {
+      try {
+        const clean = rebaseRootLinks(stripVuePressSyntax(page._strippedContent || ''), base);
+        // `.html` → `<slug>.md`; directory URL (`/guide/`) → `<dir>/index.md`.
+        const relPath = page.path.endsWith('/')
+          ? `${page.path}index.md`
+          : page.path.replace(/\.html$/, '.md');
+        const outFile = path.join(ctx.outDir, relPath.replace(/^\//, ''));
+        await fs.promises.mkdir(path.dirname(outFile), { recursive: true });
+        await fs.promises.writeFile(outFile, clean, 'utf8');
+
+        const url = hostname + base.replace(/\/$/, '') + page.path.replace(/\.html$/, '');
+        // The per-page `.md` keeps relative links (resolve within the companion
+        // tree); the aggregated corpus needs absolute links (single-file URL).
+        corpus.push('---', '', `## ${page.title || page.path}`, '', `URL: ${url}`, '', absolutizeLinks(clean, url), '');
+      } catch (err) {
+        console.warn(`[md-companions] skipping ${page.path}: ${err.message}`);
+      }
+    }
+
+    // Best-effort like the per-page writes: a corpus-write failure warns rather
+    // than aborting the whole docs build.
+    const corpusText = corpus.join('\n');
+    try {
+      await fs.promises.writeFile(path.join(ctx.outDir, 'llms-full.txt'), corpusText, 'utf8');
+    } catch (err) {
+      console.warn(`[md-companions] failed to write llms-full.txt: ${err.message}`);
+    }
+
+    // The site is served under base `/docs/` (GH Pages in prod, Netlify preview),
+    // but the llms.txt convention expects the index at the domain ROOT. Mirror
+    // both files one level above the base dir (the served root) so `/llms.txt`
+    // and `/llms-full.txt` resolve on GH Pages — where netlify.toml redirects do
+    // not apply. Best-effort: never fail the build over the mirror.
+    try {
+      const root = path.dirname(ctx.outDir);
+      await fs.promises.writeFile(path.join(root, 'llms-full.txt'), corpusText, 'utf8');
+      const indexTxt = await fs.promises
+        .readFile(path.join(ctx.outDir, 'llms.txt'), 'utf8')
+        .catch(() => null);
+      if (indexTxt) await fs.promises.writeFile(path.join(root, 'llms.txt'), indexTxt, 'utf8');
+    } catch (err) {
+      console.warn(`[md-companions] failed to mirror llms files to site root: ${err.message}`);
+    }
+  }
+});
diff --git a/docs/.vuepress/plugins/md-companions/strip.js b/docs/.vuepress/plugins/md-companions/strip.js
new file mode 100644
index 0000000000..62c34b3c3e
--- /dev/null
+++ b/docs/.vuepress/plugins/md-companions/strip.js
@@ -0,0 +1,159 @@
+/**
+ * Neutralise inline Vue-only markup on a single prose line: `[[toc]]`,
+ * Vue-bound `<a :href>` (keep text) / `<img :src>` (drop), and inline
+ * self-closing PascalCase components (`<Badge …/>`; the `[A-Z]` guard leaves
+ * plain HTML like `<br/>` alone). `{{ … }}` interpolations are left verbatim.
+ * @param {string} line
+ * @returns {string}
+ */
+function cleanInlineMarkup(line) {
+  return line
+    .replace(/\[\[toc\]\]/gi, '')
+    .replace(/<a\s[^>]*:href[^>]*>(.*?)<\/a>/gi, '$1')
+    .replace(/<img\s[^>]*:src[^>]*\/?>/gi, '')
+    .replace(/\s*<[A-Z][A-Za-z0-9]*(?:\s[^>]*?)?\/>/g, '');
+}
+
+/**
+ * Strips VuePress-specific markdown syntax, producing clean markdown
+ * suitable for LLM consumption. Fence-aware: never edits inside code blocks.
+ * @param {string} src raw markdown (frontmatter already removed)
+ * @returns {string} cleaned markdown
+ */
+function stripVuePressSyntax(src) {
+  const lines = src.split('\n');
+  const out = [];
+  let inFence = false;
+  let fenceMarker = '';
+  let inScript = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    const fenceMatch = trimmed.match(/^(```+|~~~+)/);
+    if (fenceMatch && !inScript) {
+      if (!inFence) {
+        inFence = true;
+        fenceMarker = fenceMatch[1];   // full marker e.g. "```" or "````"
+      } else {
+        const closeMatch = trimmed.match(/^(```+|~~~+)/);
+        if (closeMatch && closeMatch[1][0] === fenceMarker[0] && closeMatch[1].length >= fenceMarker.length) {
+          inFence = false;
+        }
+      }
+      out.push(line);
+      continue;
+    }
+    if (inFence) {
+      out.push(line);
+      continue;
+    }
+
+    if (/^<(script|style)[\s>]/i.test(trimmed)) {
+      // A self-contained one-liner (`<script>…</script>`) must NOT open a
+      // multi-line skip — otherwise every following line up to the next
+      // closing tag would be swallowed. Drop just this line in that case.
+      if (!/<\/(script|style)>/i.test(trimmed)) inScript = true;
+      continue;
+    }
+    if (inScript) {
+      if (/<\/(script|style)>/i.test(trimmed)) inScript = false;
+      continue;
+    }
+
+    if (/^<[A-Z][A-Za-z0-9]*(\s[^>]*)?\/?>$/.test(trimmed)) continue;
+
+    // Whole-line closing tag of a paired block component (e.g. `</Collapse>`) — drop the
+    // tag but keep the inner content that sits between it and its opening tag.
+    if (/^<\/[A-Z][A-Za-z0-9]*>$/.test(trimmed)) continue;
+
+    if (/^\[\[toc\]\]$/i.test(trimmed)) continue;
+
+    const open = trimmed.match(/^:::\s*(\w+)\s*(.*)$/i);
+    if (open) {
+      const type = open[1].toLowerCase();
+      const title = open[2].trim();
+      const body = [];
+      i++;
+      const bodyStart = i;
+      // Fence-aware close: a bare `:::` inside a fenced code block in the body is
+      // NOT the container closer.
+      let bodyFence = false;
+      let bodyMarker = '';
+      while (i < lines.length) {
+        const bt = lines[i].trim();
+        const bfm = bt.match(/^(```+|~~~+)/);
+        if (bfm) {
+          if (!bodyFence) { bodyFence = true; bodyMarker = bfm[1]; }
+          else if (bfm[1][0] === bodyMarker[0] && bfm[1].length >= bodyMarker.length) { bodyFence = false; }
+        } else if (!bodyFence && bt === ':::') {
+          break;
+        }
+        body.push(lines[i]);
+        i++;
+      }
+      // If we hit EOF without finding closing :::, emit verbatim (not a real container).
+      if (i >= lines.length) {
+        out.push(lines[bodyStart - 1]); // re-emit the opening line
+        body.forEach(b => out.push(b));
+        continue;
+      }
+      // Demo/example containers (live code runners) are not prose — omit entirely.
+      if (type === 'example') { continue; }
+      if (title) { out.push(`> **${title}**`); out.push('>'); }
+      // Container bodies must run through the same inline cleanup as normal
+      // prose, otherwise Vue markup inside a tip/warning leaks into companions.
+      body.forEach(b => out.push(b.trim() === '' ? '>' : `> ${cleanInlineMarkup(b)}`));
+      while (out.length && out[out.length - 1] === '>') out.pop();
+      continue;
+    }
+
+    // Normal prose line: run the shared inline cleanup (see cleanInlineMarkup).
+    out.push(cleanInlineMarkup(line));
+  }
+
+  // Collapse runs of blank lines to a single blank — but NEVER inside code
+  // fences, where consecutive blank lines are significant code content.
+  const collapsed = [];
+  let outFence = false;
+  let outMarker = '';
+  let blanks = 0;
+  for (const l of out) {
+    const t = l.trim();
+    const fm = t.match(/^(```+|~~~+)/);
+    if (fm && (!outFence || (fm[1][0] === outMarker[0] && fm[1].length >= outMarker.length))) {
+      if (!outFence) { outFence = true; outMarker = fm[1]; } else { outFence = false; }
+      collapsed.push(l);
+      blanks = 0;
+      continue;
+    }
+    if (outFence) { collapsed.push(l); continue; }
+    if (t === '') {
+      if (++blanks >= 2) continue;   // collapse runs of blank lines
+      collapsed.push('');            // normalise whitespace-only lines to a clean blank
+      continue;
+    }
+    blanks = 0;
+    collapsed.push(l);
+  }
+
+  // Drop trailing empty sections: a heading left with no body (e.g. a `## Demo`
+  // whose `:::example` live-demo was stripped) would otherwise dangle at EOF.
+  // Guard: only when the doc has real prose, so a page that is legitimately just
+  // a title (e.g. `# AbsoluteCellRange`) is never wiped.
+  const hasProse = collapsed.some(l => {
+    const s = l.trim();
+    return s !== '' && !/^#{1,6}\s/.test(s);
+  });
+  if (hasProse) {
+    while (collapsed.length) {
+      const last = collapsed[collapsed.length - 1].trim();
+      if (last === '' || /^#{1,6}\s/.test(last)) collapsed.pop();
+      else break;
+    }
+  }
+  return collapsed.join('\n').trim();
+}
+
+module.exports = { stripVuePressSyntax };
diff --git a/docs/.vuepress/public/llms.txt b/docs/.vuepress/public/llms.txt
new file mode 100644
index 0000000000..aade16d0bd
--- /dev/null
+++ b/docs/.vuepress/public/llms.txt
@@ -0,0 +1,10 @@
+# HyperFormula
+
+> HyperFormula is an open-source, high-performance calculation engine for spreadsheets and web applications.
+
+## Docs
+
+- Guide: https://hyperformula.handsontable.com/docs/
+- API reference: https://hyperformula.handsontable.com/docs/api/
+- Full corpus: https://hyperformula.handsontable.com/docs/llms-full.txt
+- Official Claude skill: https://github.com/handsontable/handsontable-skills
diff --git a/docs/.vuepress/theme/index.js b/docs/.vuepress/theme/index.js
new file mode 100644
index 0000000000..2870f442e3
--- /dev/null
+++ b/docs/.vuepress/theme/index.js
@@ -0,0 +1,6 @@
+// Local theme that extends `@vuepress/theme-default`. It exists solely to
+// override `layouts/Layout.vue` and inject the "View as Markdown" link at the
+// top of every guide page's content (see `./layouts/Layout.vue`).
+module.exports = {
+  extend: '@vuepress/theme-default',
+};
diff --git a/docs/.vuepress/theme/layouts/Layout.vue b/docs/.vuepress/theme/layouts/Layout.vue
new file mode 100644
index 0000000000..54e20bd655
--- /dev/null
+++ b/docs/.vuepress/theme/layouts/Layout.vue
@@ -0,0 +1,21 @@
+<template>
+  <ParentLayout>
+    <template #page-top>
+      <ViewMarkdownLink />
+    </template>
+  </ParentLayout>
+</template>
+
+<script>
+// Overrides `@vuepress/theme-default`'s `Layout.vue` only to fill the
+// `page-top` slot it exposes (rendered above `<Content>` in `Page.vue`),
+// so the "View as Markdown" link appears at the top of every guide page's
+// article body — not as a fixed floating overlay.
+import ParentLayout from '@parent-theme/layouts/Layout.vue';
+import ViewMarkdownLink from '../../components/ViewMarkdownLink.vue';
+
+export default {
+  name: 'Layout',
+  components: { ParentLayout, ViewMarkdownLink },
+};
+</script>
diff --git a/docs/README.md b/docs/README.md
index 26c9f2fb5f..94e94d0ead 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -43,10 +43,12 @@ docs                            # All documentation files
 ├── .vuepress                   # All VuePress files
 │   ├── components              # Vue components
 │   ├── dist                    # The docs output. Both the docs and the API reference are built into this folder.
+│   ├── plugins                 # VuePress plugins, incl. md-companions (see below)
 │   ├── public                  # Public assets
 │   ├── styles                  # Style-related files
 │   ├── subtheme                # Subtheme files
 │   ├── templates               # HTML templates
+│   ├── theme                   # Local theme extending the default theme (see below)
 │   ├── config.js               # VuePress configuration
 │   ├── enhanceApp.js           # VuePress app-level enhancements
 │   └── highlight.js            # Code highlight configuration
@@ -56,3 +58,12 @@ docs                            # All documentation files
 ├── index.md                    # The main docs portal welcome page
 └── README.md                   # The file you're looking at right now!
 ```
+
+## Agent-friendly build outputs
+
+`npm run docs:build` produces docs meant to be read by both people and AI coding agents:
+
+* **HTML + Markdown per page** &mdash; every guide page is built as both an `.html` page and a companion `.md` file with the same content, via the `md-companions` VuePress plugin (`.vuepress/plugins/md-companions`). The companion lives next to its HTML page, e.g. `guide/basic-usage.html` and `guide/basic-usage.md`.
+* **`llms-full.txt`** &mdash; all guide pages concatenated into one Markdown file at the docs root (`/docs/llms-full.txt`), so an agent can fetch the whole corpus in a single request instead of crawling page by page.
+* **"View as Markdown" link** &mdash; every guide page shows a small link near the top of its content that navigates to that page's `.md` companion (rendered via the local theme in `.vuepress/theme`, which overrides the default theme's `Layout.vue`).
+* **"Set up your coding agent" page** &mdash; [`guide/setup-coding-agent.md`](guide/setup-coding-agent.md) explains how to point Claude Code, Cursor, Copilot, and other agents at these machine-readable docs, and embeds the `CodingAgentWizard` component: an interactive picker that shows the right setup instructions for the agent you choose.
diff --git a/docs/guide/setup-coding-agent.md b/docs/guide/setup-coding-agent.md
new file mode 100644
index 0000000000..5f96497b2f
--- /dev/null
+++ b/docs/guide/setup-coding-agent.md
@@ -0,0 +1,45 @@
+# Set up your coding agent
+
+HyperFormula ships an official Claude skill and machine-readable docs so your AI coding agent can scaffold, configure, and debug HyperFormula correctly. Pick your tool below, or use the interactive wizard.
+
+<CodingAgentWizard />
+
+## Claude Code
+
+Install the official skill from the plugin marketplace:
+
+```
+/plugin marketplace add handsontable/handsontable-skills
+/plugin install handsontable-skills@handsontable-skills
+```
+
+Claude Code loads the `hyperformula` skill automatically based on what you ask.
+
+## Cursor, Copilot & other agents
+
+These tools don't yet support the Claude skill format. Point your agent at the machine-readable docs instead:
+
+- **Full corpus:** [`llms-full.txt`](../llms-full.txt) — the entire documentation in one LLM-friendly file.
+- **Per-page Markdown:** append `.md` to a docs page URL (e.g. `/docs/guide/basic-usage.md`), or use the **View as Markdown** link on any page.
+
+For agents that read a rules file (e.g. Cursor's `AGENTS.md`), add a line pointing at the corpus URL so the agent fetches authoritative docs on demand.
+
+## Live docs via MCP (any agent)
+
+Two zero-setup ways to let an agent pull authoritative HyperFormula docs on demand:
+
+- **GitMCP** — add the MCP server `https://gitmcp.io/handsontable/hyperformula` to your agent (e.g. `claude mcp add --transport http hyperformula https://gitmcp.io/handsontable/hyperformula`). It serves this GitHub repository's docs. No install, no auth.
+- **Context7** — run `npx -y @upstash/context7-mcp` (or use the Context7 skill / `ctx7` CLI) and ask for the `hyperformula` library. Context7 indexes the repository's `docs` folder (see `context7.json` in the repo root).
+
+## Manual install (any Claude Code setup)
+
+```bash
+git clone https://github.com/handsontable/handsontable-skills.git
+cp -r handsontable-skills/skills/hyperformula ~/.claude/skills/
+```
+
+## Resources
+
+- [Official skill repository](https://github.com/handsontable/handsontable-skills)
+- [`llms-full.txt`](../llms-full.txt)
+- [API reference](/api/)
diff --git a/netlify.toml b/netlify.toml
index f473180db4..cceb2a0d72 100644
--- a/netlify.toml
+++ b/netlify.toml
@@ -3,4 +3,10 @@
   publish = "docs/.vuepress/dist"
 
 [build.environment]
-  NODE_VERSION = "18"
+  NODE_VERSION = "22"
+
+# No redirects for the domain-root `/llms.txt` / `/llms-full.txt` paths here:
+# https://hyperformula.handsontable.com/LLMs.txt is the website repo's
+# authoritative root corpus and covers more than just the docs, so this repo
+# must not shadow it. The docs-scoped corpus stays reachable at its real
+# `/docs/llms.txt` and `/docs/llms-full.txt` paths.