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>(dialogandplatform-controls-dismiss-dialogguides): Listed as Limited availability (supported in Chrome 134, Edge 134, and Firefox 141; unsupported in Safari). Without a coordinate-checkedpointerdown+pointerupfallback, a naiveevent.target === dialoglistener 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-controlguide): Reached Baseline Newly available on December 12, 2025 (Chrome 135, Edge 135, Firefox 144, and Safari 26.2), requiring a feature-detected fallback onHTMLButtonElement.prototypefor older browsers. - CSS
field-sizing: content(form-fields-automatically-fit-contentsguide): 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:
- The distribution repository (
GoogleChrome/modern-web-guidance): Created on March 23, 2026, this is the repository users and plugins actually install from. It hitv1.0.0stable on November 10, 2026 (2026-11-10T03:24:59Z), followingv0.0.197on November 2, 2026. - The npm package (
modern-web-guidance): First published atv0.0.55on April 30, 2026, and updated to1.0.0on November 10, 2026 (2026-11-10T03:29:19Z). It bundles the compiled CLI (modern-web.mjsandlegacy-scan.mjs), an offline embedding model plus BM25 search index, and 208 compiled guide definitions (guides.json). - 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, writets-morphandlinkedomstatic 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:
# 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@googlechromeKeep 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:
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":
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:
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:
DISABLE_TELEMETRY=1 npx -y modern-web-guidance@1.0.0 retrieve "custom-text-decorations"> [!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-featuresThat 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:
<!-- 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):
DISABLE_TELEMETRY=1 npx -y modern-web-guidance@1.0.0 legacy-scan docs/editorial/fixtures/modern-web-guidance-demoautofill-sign-in-form(line 26):<input type="password">inside a credential confirmation form lackedautocomplete="current-password".customize-scrollbar-color-and-thickness(lines 8 and 11): Vendor::-webkit-scrollbarand::-webkit-scrollbar-thumbrules were used without standardscrollbar-widthandscrollbar-colordeclarations.declarative-dialog-popover-control(line 48): A pure JS click listener onopenBtnexisted only to calldeleteDialog.showModal(), which can be replaced by declarative Invoker Commands (command="show-modal" commandfor="deleteDialog").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.form-fields-automatically-fit-contents(line 63): ImperativescrollHeightrecalculation on<textarea>was used without CSSfield-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
#currentPasswordhasrequired, clicking Cancel withoutformnovalidatetriggers HTML constraint validation on the empty password field and blocks the user from canceling! - Yet
legacy-scanstill reports0 findings from 33 qualified guideson 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:
<!-- 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:
- Why we replaced bare
import("invokers-polyfill")in a plain HTML fixture: Thedeclarative-dialog-popover-controlguide offers two polyfill patterns insideif (!("commandForElement" in HTMLButtonElement.prototype)):import("invokers-polyfill")for apps with a bundler or import map, andimport("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 bareimport("invokers-polyfill")specifier throws aTypeErrorin browsers that enter the fallback branch. Using a 5-lineshowModal()loop inside the same!("commandForElement" in HTMLButtonElement.prototype)guard keeps our local fixture 100 percent offline and dependency-free. - Why
legacy-scanreports0 findingsdespite the fallback listeners: Re-runninglegacy-scanonafter-modern-settings.htmlreturned0 findings from 33 qualified guides. The AST rules inlegacy-scaninspect enclosingifstatements for feature guards ("commandForElement" in HTMLButtonElement.prototype,"closedBy" in HTMLDialogElement.prototype, andCSS.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 that0 findingsonly 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 sent0network requests. - Pressing
Escapedismissed 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) with0POST requests. - Typing a password and a five-line deletion reason expanded
#deletionReasonnatively from53pxto84pxvia CSSfield-sizing: content(style.height === ""), and clicking Delete permanently submittedPOST /api/workspace/delete(application/x-www-form-urlencoded) with bothpasswordandreasonfields and0console 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:
legacy-scancovers roughly 16 to 20 percent of the catalog, and0 findingsis not a correctness guarantee. Inmodern-web-guidance@1.0.0, the full guide catalog contains 208 guides (guides.json), butlegacy-scanruns only 35 deterministic rules across 33 guides (in the upstream-srcrepo 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, andoverscroll-behavior: containondialog::backdrop, is only applied when an agent or developer runssearchandretrievebefore writing code. And as ourmethod="dialog"vs.formmethod="dialog" formnovalidateexample showed,legacy-scandoes not validate form submission semantics, accessibility trees, or application logic.- Even inside covered guides,
legacy-scanonly checks high-precision AST/DOM patterns. In our legacy fixture,<dialog role="dialog" aria-modal="true">had redundant ARIA attributes that thedialogguide explicitly marksDON'T, and the cancel button lackedautofocus.legacy-scandid not flag either line because the maintainers qualify static rules only when held-out post-verifier precision reaches at least 90 percent. You needretrieve "dialog", not justlegacy-scan, to get the full checklist. - Path filtering skips
docs/andtests/by default. When we ranlegacy-scanfrom the repository root with a file path containingdocs/(docs/editorial/fixtures/.../before-legacy-settings.html), the DOM scanner skippedautofill-sign-in-formunless--include-docs-and-testswas passed or the directory itself was used as the scan root. If your repo keeps demo components underdocs/orexamples/, pass--include-docs-and-tests. - Unsupported and skipped styling formats. According to
src/analyzing/format-support.mdinGoogleChrome/modern-web-guidance-src,legacy-scansupports.html,.css,.js/.ts/.jsx/.tsx,.vue,.svelte,.astro,.scss/.less, andcsstagged templates. However, object-style CSS-in-JS (such as MUIsxorvanilla-extract), barestyled.divdeclarations without selectors, and.mdxfiles are intentionally skipped (expected-skiporunsupported). - 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-grindanddevtools-timesevaluation 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
Claude Code
Anthropic's CLI agent for codebase mapping, editing, and workflows.