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/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..287f4dfa7c
--- /dev/null
+++ b/docs/.vuepress/components/ViewMarkdownLink.vue
@@ -0,0 +1,72 @@
+<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'
+
+// Rendered in the `page-top` slot, this sits above `.theme-default-content`
+// at the very top of `main.page` — a zone the fixed navbar covers (the theme
+// clears the navbar only *inside* the content block, via the first heading's
+// top padding). Mirror the content wrapper's `$wrapper` geometry but take no
+// flow height: the link floats right-aligned inside the title's transparent
+// navbar-clearance padding, just above the page title, without pushing the
+// article down. `z-index` keeps it clickable above the heading's padding box.
+.view-markdown-link
+  position relative
+  z-index 1
+  max-width $contentWidth
+  height 0
+  margin 0 auto
+  padding 0 2.5rem
+  font-size 0.85rem
+
+  a
+    position absolute
+    top ($navbarHeight + 0.2rem)
+    right 2.5rem
+    line-height 1.4
+    color $accentColor
+    text-decoration none
+
+    &:hover
+      text-decoration underline
+
+// Keep the wrapper's paddings (and the anchor's `right` offset, resolved
+// against the wrapper's padding box) in lockstep with `$wrapper`'s responsive
+// paddings, so the link tracks the article text's right edge at every width.
+@media (max-width: $MQNarrow)
+  .view-markdown-link
+    padding 0 2rem
+
+    a
+      right 2rem
+
+@media (max-width: $MQMobileNarrow)
+  .view-markdown-link
+    padding 0 1.5rem
+
+    a
+      right 1.5rem
+</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 928edba203..382ae7b026 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..a1a89362df
--- /dev/null
+++ b/docs/.vuepress/plugins/md-companions/index.js
@@ -0,0 +1,145 @@
+const fs = require('fs');
+const path = require('path');
+const { stripVuePressSyntax } = require('./strip');
+
+/**
+ * Resolve the `{{ $page.* }}` interpolations that `extendPageData` injects
+ * (config.js) against the page's own values, so the companion `.md` ships the
+ * real value instead of the raw mustache. Only the known injected keys are
+ * substituted; any other `{{ … }}` is left untouched.
+ * @param {string} md raw page markdown
+ * @param {object} page VuePress page object (carries the injected fields)
+ * @returns {string}
+ */
+function resolvePageVars(md, page) {
+  return md.replace(
+    /\{\{\s*\$page\.(version|buildDate|buildDateURIEncoded|releaseDate|functionsCount)\s*\}\}/g,
+    (m, key) => (page && page[key] != null ? String(page[key]) : m)
+  );
+}
+
+/**
+ * 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 resolved = resolvePageVars(page._strippedContent || '', page);
+        const clean = rebaseRootLinks(stripVuePressSyntax(resolved), 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 docs site is served under base `/docs/`, so its corpus lives at
+    // `/docs/llms-full.txt`. The domain-root `/llms.txt` is owned by the
+    // website repo (it advertises more than just the docs), so this plugin
+    // deliberately does NOT write to the served root — see the note in
+    // netlify.toml.
+  }
+});
diff --git a/docs/.vuepress/plugins/md-companions/strip.js b/docs/.vuepress/plugins/md-companions/strip.js
new file mode 100644
index 0000000000..cfd6ac90df
--- /dev/null
+++ b/docs/.vuepress/plugins/md-companions/strip.js
@@ -0,0 +1,191 @@
+/**
+ * Neutralise inline Vue-only markup on a single prose line: `[[toc]]`,
+ * Vue-bound `<a :href>` and `<img :src>`, and inline self-closing PascalCase
+ * components (`<Badge …/>`; the `[A-Z]` guard leaves plain HTML like `<br/>`
+ * alone). `{{ … }}` interpolations are left verbatim (resolved upstream against
+ * the page data before stripping).
+ *
+ * For `:href` / `:src`, the bound value is a JS expression (e.g.
+ * `$withBase('/x.zip')` or `'https://…?v=' + $page.buildDateURIEncoded`); we
+ * extract its first string literal and emit a real Markdown link / image so the
+ * destination survives into the companion, instead of dropping it. Bindings
+ * with no string literal fall back to text (links) or are removed (images).
+ * @param {string} line
+ * @returns {string}
+ */
+function cleanInlineMarkup(line) {
+  const firstLiteral = expr => {
+    const m = expr.match(/'([^']*)'|"([^"]*)"/);
+    return m ? (m[1] !== undefined ? m[1] : m[2]) : null;
+  };
+  return line
+    .replace(/\[\[toc\]\]/gi, '')
+    .replace(/<a\b[^>]*?:href\s*=\s*"([^"]*)"[^>]*>(.*?)<\/a>/gi, (_m, expr, text) => {
+      const url = firstLiteral(expr);
+      return url ? `[${text}](${url})` : text;
+    })
+    .replace(/<img\b[^>]*?:src\s*=\s*"([^"]*)"[^>]*?\/?>/gi, (_m, expr) => {
+      const url = firstLiteral(expr);
+      return url ? `![](${url})` : '';
+    })
+    .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 run through the same inline cleanup as normal prose —
+      // EXCEPT inside fenced code blocks, where Vue-shaped samples are literal
+      // content and must survive verbatim (otherwise `<a :href>`, `<Badge/>` or
+      // `[[toc]]` shown in a tip/warning code sample get rewritten or dropped).
+      // The body scan above already located these fences; re-derive that state
+      // here so emit skips cleanInlineMarkup for code lines.
+      let emitFence = false;
+      let emitMarker = '';
+      body.forEach(b => {
+        const bfm = b.trim().match(/^(```+|~~~+)/);
+        if (bfm && (!emitFence || (bfm[1][0] === emitMarker[0] && bfm[1].length >= emitMarker.length))) {
+          if (!emitFence) { emitFence = true; emitMarker = bfm[1]; } else { emitFence = false; }
+          out.push(`> ${b}`);
+          return;
+        }
+        if (emitFence) { out.push(`> ${b}`); return; }
+        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/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..13bd10cb12 100644
--- a/netlify.toml
+++ b/netlify.toml
@@ -3,4 +3,4 @@
   publish = "docs/.vuepress/dist"
 
 [build.environment]
-  NODE_VERSION = "18"
+  NODE_VERSION = "22"