Skip to main content
rule CX Codex

js-batch-dom-css · tech-leads-club — Claude Code rule: what it does

js-batch-dom-css prevents layout thrashing by separating style updates from layout queries. Helps Claude write performant DOM and React code.

MIT ★ 7,191 updated 2026-10-24

Install into Claude Code · Manually: put the files in place All methods and platforms ↓
.claude/rules/js-batch-dom-css.md
Open on GitHub

What js-batch-dom-css does

The rule guides the coding agent to batch DOM manipulations. Interleaving style assignments with reads such as offsetWidth, offsetHeight, or getBoundingClientRect() forces the browser into costly synchronous reflows.

It establishes a strict separation: execute all layout queries first, then apply style changes, or bundle all mutations before querying. For React components, it instructs the model to toggle CSS classes rather than mutating node styles inside useEffect.

Position: inline style changes are treated as a fallback, so the rule pushes class toggles wherever styles can live in external stylesheets.

What it helps with

  • prevent forced synchronous reflows in DOM scripts
  • separate geometry reads from style mutations into distinct phases
  • replace inline style assignments with CSS class toggles
  • eliminate layout thrashing inside React lifecycle hooks

Example prompts for the agent

  • Refactor this DOM update logic to eliminate layout thrashing
  • Check this React effect for forced synchronous reflow calls
  • Batch the bounding box reads before applying transform styles

How to install js-batch-dom-css

Manually: put the files in place

.claude/rules/js-batch-dom-css.md

The paths frontmatter field limits the files

Step by step, with commands for each platform: AGENTS.md vs CLAUDE.md: what they are and which one to use

Questions about js-batch-dom-css

How to install js-batch-dom-css in Claude Code?

Save the rule content into .claude/rules/js-batch-dom-css.md in your repository root.

What layout calls does this rule flag?

It targets geometry reads like offsetWidth, offsetHeight, getBoundingClientRect(), and getComputedStyle() executed between style writes.

Why does the rule prefer CSS classes over inline styles?

CSS stylesheets are cached by browsers, keep concerns separate, and avoid accidental layout recalculations triggered by inline updates.

Source text

js-batch-dom-css.md · MIT
---
title: Avoid Layout Thrashing
impact: MEDIUM
impactDescription: prevents forced synchronous layouts and reduces performance bottlenecks
tags: javascript, dom, css, performance, reflow, layout-thrashing
---

## Avoid Layout Thrashing

Avoid interleaving style writes with layout reads. When you read a layout property (like `offsetWidth`, `getBoundingClientRect()`, or `getComputedStyle()`) between style changes, the browser is forced to trigger a synchronous reflow.

**This is OK (browser batches style changes):**
```typescript
function updateElementStyles(element: HTMLElement) {
  // Each line invalidates style, but browser batches the recalculation
  element.style.width = '100px'
  element.style.height = '200px'
  element.style.backgroundColor = 'blue'
  element.style.border = '1px solid black'
}
```

**Incorrect (interleaved reads and writes force reflows):**
```typescript
function layoutThrashing(element: HTMLElement) {
  element.style.width = '100px'
  const width = element.offsetWidth  // Forces reflow
  element.style.height = '200px'
  const height = element.offsetHeight  // Forces another reflow
}
```

**Correct (batch writes, then read once):**
```typescript
function updateElementStyles(element: HTMLElement) {
  // Batch all writes together
  element.style.width = '100px'
  element.style.height = '200px'
  element.style.backgroundColor = 'blue'
  element.style.border = '1px solid black'
  
  // Read after all writes are done (single reflow)
  const { width, height } = element.getBoundingClientRect()
}
```

**Correct (batch reads, then writes):**
```typescript
function avoidThrashing(element: HTMLElement) {
  // Read phase - all layout queries first
  const rect1 = element.getBoundingClientRect()
  const offsetWidth = element.offsetWidth
  const offsetHeight = element.offsetHeight
  
  // Write phase - all style changes after
  element.style.width = '100px'
  element.style.height = '200px'
}
```

**Better: use CSS classes**
```css
.highlighted-box {
  width: 100px;
  height: 200px;
  background-color: blue;
  border: 1px solid black;
}
```
```typescript
function updateElementStyles(element: HTMLElement) {
  element.classList.add('highlighted-box')
  
  const { width, height } = element.getBoundingClientRect()
}
```

**React example:**
```tsx
// Incorrect: interleaving style changes with layout queries
function Box({ isHighlighted }: { isHighlighted: boolean }) {
  const ref = useRef<HTMLDivElement>(null)
  
  useEffect(() => {
    if (ref.current && isHighlighted) {
      ref.current.style.width = '100px'
      const width = ref.current.offsetWidth // Forces layout
      ref.current.style.height = '200px'
    }
  }, [isHighlighted])
  
  return <div ref={ref}>Content</div>
}

// Correct: toggle class
function Box({ isHighlighted }: { isHighlighted: boolean }) {
  return (
    <div className={isHighlighted ? 'highlighted-box' : ''}>
      Content
    </div>
  )
}
```

Prefer CSS classes over inline styles when possible. CSS files are cached by the browser, and classes provide better separation of concerns and are easier to maintain.

See [this gist](https://gist.github.com/paulirish/5d52fb081b3570c81e3a) and [CSS Triggers](https://csstriggers.com/) for more information on layout-forcing operations.

© tech-leads-club · MIT · tech-leads-club/agent-skills

Similar IDE rules

All IDE rules for Frontend and UI →

js-batch-dom-css by other authors comes first.

js-batch-dom-css jarrodwatts js-batch-dom-css — a Claude rule that keeps the agent from writing styles one property at a time and pushes it toward a class or a single cssText string. CX Codex +1 ★ 1,064repo stars inspecting-hermes-desktop-dom Hermes Agent The inspecting-hermes-desktop-dom skill reads the live DOM, computed CSS, and console output from Hermes Desktop over CDP. Use it to check whether a UI change took effect or identify the style rule in control. CX Codex +1 263installs expo-dom expo expo-dom runs web code in a webview on native platforms and renders as-is on web. Lets you use web libraries like recharts or react-syntax-highlighter in Expo without rewriting. CX Codex +1 25,700installs measuring-dom-nodes coleam00 The measuring-dom-nodes rule covers measuring DOM element sizes inside Remotion compositions without the video container's scale distorting the numbers. CX Codex +1 ★ 849repo stars js-performance-patterns patterns.dev js-performance-patterns is a Claude Code skill with runtime patterns for JavaScript hot paths, including tight loops, frequent event callbacks, and DOM operations. CX Codex +1 716installs pixijs-scene-dom-container pixijs pixijs-scene-dom-container teaches the agent how to overlay HTML elements on a PixiJS v8 canvas with DOMContainer and DOMPipe. Useful for native inputs, iframes or video that must follow a display object. CX Codex +1 6,900installs view-transitions patterns.dev Teaches your agent the View Transitions API, so page and UI state changes animate without hand-written animation code. CX Codex +1 707installs

From the same set130

The whole set →
architecture-compound-components The architecture-compound-components rule describes splitting complex UI components into pieces that share state through context. It fits components that have accumulated render props and conditional options. CX Codex +1 ★ 7,191repo stars state-decouple-implementation state-decouple-implementation — a Claude Code rule that keeps state management inside providers and exposes only a context interface to UI components. Swap useState for Zustand or a server sync without touching a single UI file. CX Codex +1 ★ 7,191repo stars rerender-functional-setstate The rerender-functional-setstate rule recommends functional state updates when the next React value depends on the current one. It helps callbacks avoid stale state and unnecessary dependencies. CX Codex +1 ★ 7,191repo stars state-lift-state state-lift-state — a Claude Code rule that moves React state into a provider component, so siblings outside the main UI read and update it without prop drilling or refs. CX Codex +1 ★ 7,191repo stars docs-writer The docs-writer skill creates, edits, and reviews project documentation. Use it for READMEs, Markdown files, and pages under docs/. CX Codex +1 ★ 7,191repo stars perf-astro The perf-astro Claude Code skill tunes Astro builds with inlined critical CSS, minification, non-blocking fonts and an LCP preload, aiming for 95+ Lighthouse scores. CX Codex +1 ★ 7,191repo stars tactical-ddd Audits domain models for anemia and refactors them into rich aggregates using tactical DDD patterns in Claude Code. CX Codex +1 ★ 7,191repo stars nx-workspace nx-workspace — a skill for exploring an Nx monorepo from the CLI: list projects, read resolved config, find affected projects and wire affected commands into CI. CX Codex +1 ★ 7,191repo stars

Project sponsors

Companies that keep this analytics open