Skip to content

Modern Web Guidance: Stop AI Agents Writing 2019 CSS

SangamSangamHead of AI & Digital Solutions
14 min read
Published

Ask a frontier coding agent for a confirmation modal, an auto-expanding textarea, and a custom scrollbar today, and watch what year it wakes up in.

Give an unguided coding agent that prompt in a typical frontend repository, and the output still routinely comes back looking like a 2019 relic. You get a click listener wired to a button just to open a modal, a backdrop listener that checks event.target === dialog and accidentally closes the window when a user drags to select text, an input event handler that recalculates scrollHeight on every keystroke, and a stack of -webkit-scrollbar rules that Firefox ignores. The code compiles. It passes a quick visual check. And it quietly rebuilds three platform primitives the browser already ships natively.

Modern Web Guidance (GoogleChrome/modern-web-guidance, which reached v1.0.0 stable on November 10, 2026) is an Apache-2.0 agent skill and offline CLI built to fix that exact time warp. Stewarded by the Google Chrome, Microsoft Edge, Mozilla Firefox, and MDN teams, it gives coding agents like Claude Code, OpenAI Codex, GitHub Copilot CLI, and Google Antigravity on-demand access to 208 curated web platform guides and a deterministic legacy scanner.

To evaluate the release for this guide, our engineering workflow tested the modern-web-guidance@1.0.0 CLI locally on November 14, 2026 (macOS, zsh, testing both Node v20.19.4 and Node v22.23.2 with DISABLE_TELEMETRY=1) against a hand-authored, reproducible local fixture in our repository (docs/editorial/fixtures/modern-web-guidance-demo/), and verified the rendered fixture in Chromium (including an independent clean-worktree reproduction in Playwright Chromium 145.0.7632.6) with an intercepted local mock POST endpoint. Note that our agent test harness verified the deterministic CLI and browser behavior directly rather than running a paid multi-agent benchmark. Here is how the tool works under the hood, what broke on the first run, what legacy-scan catches (and misses), and how to wire the modernized output so it actually works in a browser.

Why AI Coding Agents Default to 2019 Frontend Patterns

As the GoogleChrome/modern-web-guidance README explains in its "Why?" section, coding agents often default to older patterns because LLM training data contains vast amounts of legacy code, leading them to generate bloated JavaScript for tasks that now have native web platform solutions. Even when a model knows a newer API exists, the maintainers note that it often lacks the density of real-world implementation patterns required for production-ready code.

Think of an unguided coding agent like a general contractor working from an older municipal building code binder. The contractor is not lazy or incompetent. If you ask for a staircase, they will build a sturdy older staircase with every extra brace that used to be required before modern steel hangers existed. Because older imperative modal toggles, scrollHeight textarea resizers, and -webkit-scrollbar rules remain widespread across public codebases, models readily reproduce them unless given targeted constraints.

Even when a prompt names a modern feature such as the native <dialog> element, the Popover API, Invoker Commands (commandfor and command), or CSS field-sizing: content, an agent rarely pulls in the full set of browser-support boundaries and fallback invariants on its own. According to the compatibility data inside the modern-web-guidance@1.0.0 guides (verified on November 14, 2026):

  • <dialog closedby> (dialog and platform-controls-dismiss-dialog guides): Listed as Limited availability (supported in Chrome 134, Edge 134, and Firefox 141; unsupported in Safari). Without a coordinate-checked pointerdown + pointerup fallback, a naive event.target === dialog listener will close the modal if a user starts highlighting text inside the dialog and releases the pointer over the backdrop.
  • Invoker Commands (declarative-dialog-popover-control guide): Reached Baseline Newly available on December 12, 2025 (Chrome 135, Edge 135, Firefox 144, and Safari 26.2), requiring a feature-detected fallback on HTMLButtonElement.prototype for older browsers.
  • CSS field-sizing: content (form-fields-automatically-fit-contents guide): Reached Baseline Newly available on June 16, 2026 (Chrome 123, Edge 123, Firefox 152, and Safari 26.2).

Stuffing all of those compatibility rules into your root CLAUDE.md rules file does not scale either. You cannot paste 208 web platform guides into a file that loads on every turn without torching your context window.

Modern Web Guidance takes a different approach. The installed skill definition (SKILL.md) costs roughly 205 tokens at session start. It instructs the agent to run a local, zero-network CLI (modern-web-guidance search and modern-web-guidance retrieve) before writing HTML, CSS, or client-side JavaScript, pulling only the specific guide a task needs into context.

Two Repos, Four Dates, and What Actually Shipped

Because GoogleChrome/modern-web-guidance-src surfaced on GitHub trend lists on November 14, 2026, it is easy to mistake it for a brand-new release or install from the wrong repository. Live verification against the GitHub API, npm registry, and Chrome developer documentation on November 14, 2026 clarifies the split:

  1. The distribution repository (GoogleChrome/modern-web-guidance): Created on March 23, 2026, this is the repository users and plugins actually install from. It hit v1.0.0 stable on November 10, 2026 (2026-11-10T03:24:59Z), following v0.0.197 on November 2, 2026.
  2. The npm package (modern-web-guidance): First published at v0.0.55 on April 30, 2026, and updated to 1.0.0 on November 10, 2026 (2026-11-10T03:29:19Z). It bundles the compiled CLI (modern-web.mjs and legacy-scan.mjs), an offline embedding model plus BM25 search index, and 208 compiled guide definitions (guides.json).
  3. The authoring and evaluation repository (GoogleChrome/modern-web-guidance-src): Created on January 27, 2026 and pushed daily through November 14, 2026 (2026-11-14T14:28:09Z), this is where the Chrome, Edge, Firefox, and MDN contributors author guides, write ts-morph and linkedom static analyzer rules, and run end-to-end Playwright evaluations.

Note also what the tool is not. It is not an MCP server, and it does not connect to a live browser tab. If you want an agent to inspect live DOM state, network waterfalls, or console errors in Chrome, that is a separate project (ChromeDevTools/chrome-devtools-mcp, which shipped v1.13.0 on November 11, 2026) and belongs in your MCP server stack. Modern Web Guidance operates before and during code generation so you have fewer layout and accessibility bugs to debug later.

Hands-On Setup, Version Pinning, and the Node 22 Gotcha

According to the official GoogleChrome/modern-web-guidance README, you can run the interactive installer (which delegates to the Vercel Skills CLI, npx -y skills add GoogleChrome/modern-web-guidance) or register the skill through agent-specific plugin commands documented for Claude Code, OpenAI Codex, GitHub Copilot CLI, Google Antigravity, GitHub CLI, Grok Build CLI, and Kimi Code:

sh
# Option A: Interactive skill installer (delegates to `npx -y skills add GoogleChrome/modern-web-guidance`)
DISABLE_TELEMETRY=1 npx -y modern-web-guidance@1.0.0 install
 
# Option B: Choose specific skill packs (modern-web-guidance ~205 tokens, chrome-extensions ~175 tokens)
DISABLE_TELEMETRY=1 npx -y modern-web-guidance@1.0.0 install --choose
 
# Option C: Claude Code / GitHub Copilot CLI plugin marketplace commands (unpinned; tracks upstream repo)
/plugin marketplace add GoogleChrome/modern-web-guidance
/plugin install modern-web-guidance@googlechrome

Keep one reproducibility detail in mind when setting up a team repo: pinning @1.0.0 on npx -y modern-web-guidance@1.0.0 search|retrieve|legacy-scan locks the exact 1.0.0 CLI and its 208 bundled guides. By contrast, install (which invokes skills add GoogleChrome/modern-web-guidance), the /plugin marketplace add GoogleChrome/modern-web-guidance commands, and the CLI's own @latest opt-in prompts all pull from the unpinned upstream repository or @latest tag, so their behavior can drift as new guides and rules land.

When our test harness ran the CLI for the first time in the default project shell on November 14, 2026, it exited immediately with code 1:

text
npm warn EBADENGINE Unsupported engine {
  package: 'modern-web-guidance@1.0.0',
  required: { node: '>=22.0.0', vscode: '^1.90.0' },
  current: { node: 'v20.19.4', npm: '10.8.2' }
}
modern-web-guidance requires Node.js >= 22 (current: v20.19.4). Please upgrade: https://nodejs.org/

That is the first practical trap to know about. Many Next.js production repositories (including ours) still pin Node 20 LTS in .nvmrc or CI workflows. modern-web-guidance@1.0.0 checks process.versions.node at startup (src/cli/node-version.ts) and refuses to run on Node 20. Switching our shell PATH to Node v22.23.2 resolved the failure immediately.

A second detail worth configuring before you put this in a team workflow is telemetry. While the semantic search engine (search), guide fetcher (retrieve), and static analyzer (legacy-scan) run 100 percent locally with zero LLM or API key dependencies, the CLI collects anonymous usage telemetry by default (installation counts, calling agent name, guide IDs retrieved, and search query strings, implemented in src/cli/modern-web.ts). Raw user prompts are not sent, but on client or proprietary repositories you should export DISABLE_TELEMETRY=1 in your shell profile or agent environment block.

How the Three Core Commands Work in Practice

Once running under Node v22.23.2 with DISABLE_TELEMETRY=1, the CLI exposes two distinct workflows: pre-generation lookup (search + retrieve) and brownfield static analysis (legacy-scan).

1. Pre-Generation Lookup: search and retrieve

When an agent has the skill installed and you ask for a UI feature, SKILL.md instructs the agent to run a 2 to 5 word action-oriented query before writing code, stripping out framework noise like "React" or "Tailwind":

sh
DISABLE_TELEMETRY=1 npx -y modern-web-guidance@1.0.0 search "confirmation modal dialog"

Running that command locally returned 10 ranked JSON matches in under a second, led by dialog, declarative-dialog-popover-control, platform-controls-dismiss-dialog, prevent-page-scroll-under-modal-dialog, and light-dismiss-a-dialog.

The agent then fetches the matching guides by ID:

sh
DISABLE_TELEMETRY=1 npx -y modern-web-guidance@1.0.0 retrieve "dialog,light-dismiss-a-dialog"

One subtle engineering detail surfaced when testing retrieve: because the combined output of dialog and light-dismiss-a-dialog was 16.3 KB (312 lines), the CLI did not dump all 312 lines to stdout where an agent harness might truncate the middle. Instead, it wrote the full markdown to a temporary file (/var/folders/.../mwg-guide-*.md) and printed a two-line instruction telling the agent to read that file path in full with its file-reading tool.

2. Safety Valves: Origin Trial and Volatile Feature Gates

What happens if an agent searches for a bleeding-edge API that only exists in Chrome Canary or shipped in a single browser engine last month?

In modern-web-guidance@1.0.0, 18 of the 208 guides are gated behind explicit project opt-ins: 10 cover volatile features (single-engine APIs such as custom-text-decorations, language-model, summarizer, and 2d-panning) and 8 cover Origin Trials (such as webmcp and agentic-forms). They remain discoverable via search, so the agent knows a guide exists, but calling retrieve without opting in returns a [!CAUTION] block instead of the guide:

sh
DISABLE_TELEMETRY=1 npx -y modern-web-guidance@1.0.0 retrieve "custom-text-decorations"
text
> [!CAUTION]
> **Volatile features require explicit project opt-in.** Never bypass this gate
> (do not run `set-allow-volatile-features` yourself, edit `.mwgrc`, or read raw
> `.md` guide files from disk)...
> Ask the user if they want to opt in by running this command in their terminal:
> npx modern-web-guidance@latest set-allow-volatile-features

That gate prevents an autonomous coding agent from quietly shipping a single-engine CSS property or experimental Origin Trial into production unless a human explicitly commits "allowVolatileFeatures": true or "allowOriginTrials": true in .mwgrc (note that the printed opt-in command uses @latest, so pin @1.0.0 if you want the exact version we tested).

Reproducible Local Fixture: Before and After legacy-scan

To test what the brownfield scanner (legacy-scan) catches and where its blind spots lie, we authored a self-contained fixture pair in docs/editorial/fixtures/modern-web-guidance-demo/.

The legacy file, before-legacy-settings.html (67 lines), models a "Delete Workspace" confirmation modal containing five legacy patterns:

html
<!-- Excerpt from docs/editorial/fixtures/modern-web-guidance-demo/before-legacy-settings.html (67 lines total) -->
<style>
  .audit-log::-webkit-scrollbar { width: 8px; }
  .audit-log::-webkit-scrollbar-thumb { background: #94a3b8; border-radius: 4px; }
</style>
 
<button id="openDeleteBtn" type="button">Delete Workspace</button>
 
<dialog id="deleteDialog" role="dialog" aria-modal="true" aria-labelledby="deleteTitle">
  <h2 id="deleteTitle">Delete workspace permanently?</h2>
  <form id="deleteConfirmForm" action="/api/workspace/delete" method="post">
    <label for="currentPassword">Confirm password</label>
    <input id="currentPassword" type="password" name="password" required />
    <label for="deletionReason">Reason for deletion</label>
    <textarea id="deletionReason" name="reason" rows="2"></textarea>
    <button id="cancelDeleteBtn" type="button">Cancel</button>
    <button type="submit">Delete permanently</button>
  </form>
</dialog>
 
<script>
  openBtn.addEventListener("click", () => { deleteDialog.showModal(); });
  cancelBtn.addEventListener("click", () => { deleteDialog.close(); });
  deleteDialog.addEventListener("click", (event) => {
    if (event.target === deleteDialog) deleteDialog.close();
  });
  reasonTextarea.addEventListener("input", () => {
    reasonTextarea.style.height = "auto";
    reasonTextarea.style.height = `${reasonTextarea.scrollHeight}px`;
  });
</script>

Running legacy-scan against that directory under Node v22.23.2 took less than a second and flagged 6 findings across 5 guides (out of the 33 guides and 35 deterministic rules shipped in v1.0.0):

sh
DISABLE_TELEMETRY=1 npx -y modern-web-guidance@1.0.0 legacy-scan docs/editorial/fixtures/modern-web-guidance-demo
  1. autofill-sign-in-form (line 26): <input type="password"> inside a credential confirmation form lacked autocomplete="current-password".
  2. customize-scrollbar-color-and-thickness (lines 8 and 11): Vendor ::-webkit-scrollbar and ::-webkit-scrollbar-thumb rules were used without standard scrollbar-width and scrollbar-color declarations.
  3. declarative-dialog-popover-control (line 48): A pure JS click listener on openBtn existed only to call deleteDialog.showModal(), which can be replaced by declarative Invoker Commands (command="show-modal" commandfor="deleteDialog").
  4. dialog (line 55): An unguarded manual backdrop click listener (if (event.target === deleteDialog) deleteDialog.close()) was used instead of declarative <dialog closedby="any"> with a feature-detected fallback.
  5. form-fields-automatically-fit-contents (line 63): Imperative scrollHeight recalculation on <textarea> was used without CSS field-sizing: content.

Even better, when you pass --json, legacy-scan emits a verifierRubric (keepWhen and dropWhen arrays) for every finding so a coding agent or human reviewer can filter out false positives before editing a single line.

Hand-Authoring the Modernized Fixture (0 Scanner Findings + Browser Verification)

Next, we manually edited the fixture following the retrieved dialog, declarative-dialog-popover-control, customize-scrollbar-color-and-thickness, autofill-sign-in-form, and form-fields-automatically-fit-contents guides to produce after-modern-settings.html (109 lines).

One crucial lesson surfaced immediately while building after-modern-settings.html: 0 findings from legacy-scan only proves that none of the 35 static AST/DOM/CSS rules matched. It is not proof that your form semantics, network submission, or module imports work in a browser, and it is not evidence that an LLM agent would produce this file automatically.

For example, the dialog guide illustrates <form method="dialog"> for simple confirmation dialogs that close locally. If you replace <form action="/api/workspace/delete" method="post"> with <form method="dialog"> on a server-backed deletion form and make both Cancel and Delete permanently plain <button type="submit"> controls:

  • Clicking Delete permanently only closes the dialog and never sends POST /api/workspace/delete.
  • Worse, because #currentPassword has required, clicking Cancel without formnovalidate triggers HTML constraint validation on the empty password field and blocks the user from canceling!
  • Yet legacy-scan still reports 0 findings from 33 qualified guides on that broken form.

To preserve the exact POST /api/workspace/delete contract while allowing password-free cancelation and zero-dependency offline execution, after-modern-settings.html pairs <form action="/api/workspace/delete" method="post"> with formmethod="dialog" formnovalidate on the Cancel button:

html
<!-- Excerpt from docs/editorial/fixtures/modern-web-guidance-demo/after-modern-settings.html (109 lines total) -->
<style>
  dialog:modal { overscroll-behavior: contain; }
  dialog::backdrop {
    overflow: hidden;
    overscroll-behavior: contain;
    background-color: rgb(15 23 42 / 0.45);
  }
  #deletionReason {
    field-sizing: content;
    min-block-size: 3lh;
    max-block-size: 10lh;
  }
  .audit-log {
    scrollbar-width: thin;
    scrollbar-color: #94a3b8 transparent;
  }
</style>
 
<button type="button" command="show-modal" commandfor="deleteDialog">
  Delete Workspace
</button>
 
<dialog id="deleteDialog" closedby="any" aria-labelledby="deleteTitle">
  <h2 id="deleteTitle">Delete workspace permanently?</h2>
  <form id="deleteConfirmForm" action="/api/workspace/delete" method="post">
    <label for="currentPassword">Confirm password</label>
    <input
      id="currentPassword"
      type="password"
      name="password"
      autocomplete="current-password"
      required
    />
    <label for="deletionReason">Reason for deletion</label>
    <textarea id="deletionReason" name="reason"></textarea>
    <button type="submit" formmethod="dialog" formnovalidate value="cancel" autofocus>
      Cancel
    </button>
    <button type="submit" formmethod="post" formaction="/api/workspace/delete" value="delete">
      Delete permanently
    </button>
  </form>
</dialog>
 
<script type="module">
  const deleteDialog = document.getElementById("deleteDialog");
  const reasonTextarea = document.getElementById("deletionReason");
 
  if (!("commandForElement" in HTMLButtonElement.prototype)) {
    for (const btn of document.querySelectorAll('button[command="show-modal"][commandfor]')) {
      btn.addEventListener("click", () => {
        document.getElementById(btn.getAttribute("commandfor"))?.showModal();
      });
    }
  }
  if (!("closedBy" in HTMLDialogElement.prototype)) {
    const isOutside = (event, dlg) => {
      const rect = dlg.getBoundingClientRect();
      return (
        event.clientX < rect.left || event.clientX > rect.right ||
        event.clientY < rect.top || event.clientY > rect.bottom
      );
    };
    let pressedOutside = false;
    deleteDialog.addEventListener("pointerdown", (e) => { pressedOutside = isOutside(e, deleteDialog); });
    deleteDialog.addEventListener("pointerup", (e) => {
      if (pressedOutside && isOutside(e, deleteDialog)) deleteDialog.close();
    });
  }
  if (!CSS.supports("field-sizing", "content")) {
    reasonTextarea.addEventListener("input", () => {
      reasonTextarea.style.height = "auto";
      reasonTextarea.style.height = `${reasonTextarea.scrollHeight}px`;
    });
  }
</script>

Notice two implementation details in that script block:

  1. Why we replaced bare import("invokers-polyfill") in a plain HTML fixture: The declarative-dialog-popover-control guide offers two polyfill patterns inside if (!("commandForElement" in HTMLButtonElement.prototype)): import("invokers-polyfill") for apps with a bundler or import map, and import("https://esm.run/invokers-polyfill") for plain HTML pages with network access. In a standalone HTML file served without a bundler or import map, a bare import("invokers-polyfill") specifier throws a TypeError in browsers that enter the fallback branch. Using a 5-line showModal() loop inside the same !("commandForElement" in HTMLButtonElement.prototype) guard keeps our local fixture 100 percent offline and dependency-free.
  2. Why legacy-scan reports 0 findings despite the fallback listeners: Re-running legacy-scan on after-modern-settings.html returned 0 findings from 33 qualified guides. The AST rules in legacy-scan inspect enclosing if statements for feature guards ("commandForElement" in HTMLButtonElement.prototype, "closedBy" in HTMLDialogElement.prototype, and CSS.supports("field-sizing", "content")). When legacy listeners are wrapped inside those feature-detection guards as progressive-enhancement fallbacks, the static scanner stays quiet. Again, remember that 0 findings only confirms the 33 rule-backed guides did not match; always verify runtime behavior in a real browser.

To verify runtime behavior beyond static analysis, we served after-modern-settings.html locally on 127.0.0.1 with an intercepted mock POST /api/workspace/delete route and tested all five interactions in Chromium (plus a simulated fallback pass with HTMLButtonElement.prototype.commandForElement removed in Playwright Chromium 145.0.7632.6):

  • Clicking Delete Workspace (command="show-modal" commandfor="deleteDialog") opened <dialog id="deleteDialog"> in the top layer (:modal === true) and placed initial keyboard focus (autofocus) on Cancel.
  • Clicking Cancel (formmethod="dialog" formnovalidate) with an empty password field closed the modal immediately (returnValue: "cancel"), returned focus to Delete Workspace, and sent 0 network requests.
  • Pressing Escape dismissed the modal cleanly and returned focus to Delete Workspace.
  • Clicking Delete permanently with an empty password kept the modal open and triggered native constraint validation (validity.valueMissing === true) with 0 POST requests.
  • Typing a password and a five-line deletion reason expanded #deletionReason natively from 53px to 84px via CSS field-sizing: content (style.height === ""), and clicking Delete permanently submitted POST /api/workspace/delete (application/x-www-form-urlencoded) with both password and reason fields and 0 console errors.

Where It Falls Short: Five Limitations to Know Before Relying on It

If you install Modern Web Guidance expecting a magic linter that catches every bad frontend habit or guarantees bug-free forms, you will misread what the tool is doing. Here are five concrete boundaries we verified during testing:

  1. legacy-scan covers roughly 16 to 20 percent of the catalog, and 0 findings is not a correctness guarantee. In modern-web-guidance@1.0.0, the full guide catalog contains 208 guides (guides.json), but legacy-scan runs only 35 deterministic rules across 33 guides (in the upstream -src repo on November 14, 2026, that count had grown to 41 rules across 37 guides). The remaining ~80 percent of the corpus, including container queries, subgrid, view transitions, and overscroll-behavior: contain on dialog::backdrop, is only applied when an agent or developer runs search and retrieve before writing code. And as our method="dialog" vs. formmethod="dialog" formnovalidate example showed, legacy-scan does not validate form submission semantics, accessibility trees, or application logic.
  2. Even inside covered guides, legacy-scan only checks high-precision AST/DOM patterns. In our legacy fixture, <dialog role="dialog" aria-modal="true"> had redundant ARIA attributes that the dialog guide explicitly marks DON'T, and the cancel button lacked autofocus. legacy-scan did not flag either line because the maintainers qualify static rules only when held-out post-verifier precision reaches at least 90 percent. You need retrieve "dialog", not just legacy-scan, to get the full checklist.
  3. Path filtering skips docs/ and tests/ by default. When we ran legacy-scan from the repository root with a file path containing docs/ (docs/editorial/fixtures/.../before-legacy-settings.html), the DOM scanner skipped autofill-sign-in-form unless --include-docs-and-tests was passed or the directory itself was used as the scan root. If your repo keeps demo components under docs/ or examples/, pass --include-docs-and-tests.
  4. Unsupported and skipped styling formats. According to src/analyzing/format-support.md in GoogleChrome/modern-web-guidance-src, legacy-scan supports .html, .css, .js/.ts/.jsx/.tsx, .vue, .svelte, .astro, .scss/.less, and css tagged templates. However, object-style CSS-in-JS (such as MUI sx or vanilla-extract), bare styled.div declarations without selectors, and .mdx files are intentionally skipped (expected-skip or unsupported).
  5. Eval uplift numbers are vendor-reported, not independent benchmarks. We did not run paid LLM evaluations comparing guided vs. unguided agent outputs. The project README reports uplift numbers on its internal daily-grind and devtools-times evaluation apps (for example, November 8, 2026 runs in the README table showing Claude Code with Opus 5.5 rising from 57 percent unguided to 88 percent guided across 215 tasks, Codex CLI rising from 54 percent to 82 percent, and Antigravity CLI rising from 58 percent to 94 percent). Treat those as the Chrome team's internal calibration metrics rather than an independent benchmark on your own production React or Next.js codebase.

How to Fold This into Your Daily Agent Workflow

If you are building web interfaces with AI coding agents, the highest-leverage setup combines three layers that we have covered across our engineering guides:

First, keep your project architecture, build gates (npm run build, npm run lint), and repo-specific constraints in your CLAUDE.md rules file, and add a single browser-support line stating your Baseline target (for example, whether you require Safari fallbacks for Limited availability features like <dialog closedby>).

Second, install modern-web-guidance (making sure your agent shell uses Node 22+ and sets DISABLE_TELEMETRY=1) so the agent queries search and retrieve before touching HTML, CSS, or DOM scripts. That keeps the 208-guide library out of your base token budget until a frontend task actually starts, one of the core habits in our 50 Claude Code tips and 15 vibe coding best practices.

Third, pair pre-generation guidance with post-generation verification. Run legacy-scan during code review or in a pre-PR check, verify interactive states in a real browser, and pair both with your vibe coding debugging workflow and security rules so neither legacy DOM hacks nor broken form actions slip into main.

If your coding agent still tries to sneak custom div overlays and scrollHeight listeners into pull requests where <dialog> and field-sizing: content belong, run legacy-scan on one of your existing frontend folders this week and see which five-year-old habits are still hiding in your bundle.

DIRECTORY LINKS // TOOLS COVERED

Tools & Platforms in This Guide

View all 19 tools →
CLI AgentsTerminal CLI & GitHub Actions

Claude Code

Anthropic's CLI agent for codebase mapping, editing, and workflows.

WEEKLY PRACTITIONER DISPATCH

Stay sharp on agentic engineering.

Get practical guides on CLAUDE.md rules, verification loops, tool trade-offs, and API cost math.

TEAM ADVISORY90 min session

AI Coding Workflow Diagnostic

For founders and small engineering teams (2–15 devs). A bounded 2–3 hour review of your repo rules, hooks, and agent spend, with a written recommendations memo.