diff --git a/.github/workflows/migration-status.yml b/.github/workflows/migration-status.yml
index 9b74e5e6f78..d2cf2599c1f 100644
--- a/.github/workflows/migration-status.yml
+++ b/.github/workflows/migration-status.yml
@@ -5,6 +5,19 @@ on:
   workflow_dispatch:
 
 jobs:
+  merge-props:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0
+      - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020
+        with:
+          node-version-file: '.nvmrc'
+          cache: 'npm'
+      - name: install dependencies
+        run: npm ci
+      - name: run migration script
+        run: node script/merge-props-migration-status.mts >> $GITHUB_STEP_SUMMARY
+
   react-compiler:
     runs-on: ubuntu-latest
     steps:
diff --git a/eslint.config.mjs b/eslint.config.mjs
index 22647924d8e..7092b2f8d56 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -3,6 +3,7 @@ import {fileURLToPath} from 'node:url'
 import {fixupConfigRules, fixupPluginRules} from '@eslint/compat'
 import {FlatCompat} from '@eslint/eslintrc'
 import js from '@eslint/js'
+import primerConfig from '@primer/eslint-config'
 import eslintReact from '@eslint-react/eslint-plugin'
 import vitest from '@vitest/eslint-plugin'
 import {defineConfig, globalIgnores} from 'eslint/config'
@@ -58,6 +59,7 @@ const config = defineConfig([
   ]),
 
   js.configs.recommended,
+  primerConfig,
 
   ...fixupConfigRules([react.configs.flat.recommended, react.configs.flat['jsx-runtime']]),
   reactHooks.configs.flat['recommended-latest'],
diff --git a/package-lock.json b/package-lock.json
index 055b4792707..b98d8ac49a0 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -6627,6 +6627,10 @@
       "resolved": "packages/doc-gen",
       "link": true
     },
+    "node_modules/@primer/eslint-config": {
+      "resolved": "packages/eslint-config",
+      "link": true
+    },
     "node_modules/@primer/mcp": {
       "resolved": "packages/mcp",
       "link": true
@@ -28958,6 +28962,23 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
+    "packages/eslint-config": {
+      "name": "@primer/eslint-config",
+      "version": "0.0.0",
+      "dependencies": {
+        "@typescript-eslint/utils": "^8.59.1"
+      },
+      "devDependencies": {
+        "@primer/vitest-config": "^0.0.0",
+        "@typescript-eslint/parser": "8.59.1",
+        "eslint": "^10.7.0",
+        "typescript": "^6.0.3",
+        "vitest": "^4.1.9"
+      },
+      "peerDependencies": {
+        "eslint": "^10.7.0"
+      }
+    },
     "packages/mcp": {
       "name": "@primer/mcp",
       "version": "1.0.0",
diff --git a/packages/eslint-config/package.json b/packages/eslint-config/package.json
new file mode 100644
index 00000000000..3bfbee50bb4
--- /dev/null
+++ b/packages/eslint-config/package.json
@@ -0,0 +1,24 @@
+{
+  "name": "@primer/eslint-config",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "exports": "./src/index.ts",
+  "scripts": {
+    "test": "vitest --run",
+    "type-check": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "eslint": "^10.7.0"
+  },
+  "dependencies": {
+    "@typescript-eslint/utils": "^8.59.1"
+  },
+  "devDependencies": {
+    "@primer/vitest-config": "^0.0.0",
+    "@typescript-eslint/parser": "8.59.1",
+    "eslint": "^10.7.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9"
+  }
+}
diff --git a/packages/eslint-config/src/index.test.ts b/packages/eslint-config/src/index.test.ts
new file mode 100644
index 00000000000..a85314c3b18
--- /dev/null
+++ b/packages/eslint-config/src/index.test.ts
@@ -0,0 +1,9 @@
+import {describe, expect, test} from 'vitest'
+import {config, plugin} from './index.ts'
+
+describe('@primer/eslint-config', () => {
+  test('exports the prefer-merge-props rule disabled by default', () => {
+    expect(plugin.rules?.['prefer-merge-props']).toBeDefined()
+    expect(config.rules?.['primer/prefer-merge-props']).toBe('off')
+  })
+})
diff --git a/packages/eslint-config/src/index.ts b/packages/eslint-config/src/index.ts
new file mode 100644
index 00000000000..c1d31e635e3
--- /dev/null
+++ b/packages/eslint-config/src/index.ts
@@ -0,0 +1,24 @@
+import type {TSESLint} from '@typescript-eslint/utils'
+import {preferMergeProps} from './rules/preferMergeProps.ts'
+
+const plugin: TSESLint.FlatConfig.Plugin = {
+  meta: {
+    name: '@primer/eslint-config',
+  },
+  rules: {
+    'prefer-merge-props': preferMergeProps,
+  },
+}
+
+const config: TSESLint.FlatConfig.Config = {
+  name: '@primer/eslint-config',
+  plugins: {
+    primer: plugin,
+  },
+  rules: {
+    'primer/prefer-merge-props': 'off',
+  },
+}
+
+export {config, plugin, preferMergeProps}
+export default config
diff --git a/packages/eslint-config/src/rules/preferMergeProps.test.ts b/packages/eslint-config/src/rules/preferMergeProps.test.ts
new file mode 100644
index 00000000000..7fccc3aa386
--- /dev/null
+++ b/packages/eslint-config/src/rules/preferMergeProps.test.ts
@@ -0,0 +1,214 @@
+import {RuleTester} from 'eslint'
+import tsParser from '@typescript-eslint/parser'
+import {describe, it} from 'vitest'
+import {preferMergeProps} from './preferMergeProps.ts'
+
+RuleTester.describe = describe
+RuleTester.it = it
+RuleTester.itOnly = it
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    ecmaVersion: 'latest',
+    parser: tsParser,
+    sourceType: 'module',
+    parserOptions: {
+      ecmaFeatures: {
+        jsx: true,
+      },
+    },
+  },
+})
+
+ruleTester.run('prefer-merge-props', preferMergeProps as unknown as Parameters<RuleTester['run']>[1], {
+  valid: [
+    {
+      name: 'accepts component root props merged with mergeProps',
+      code: `function Example() { return <button {...mergeProps(componentProps, props)} /> }`,
+    },
+    {
+      name: 'accepts a namespaced mergeProps utility',
+      code: `function Example() { return <button {...utils.mergeProps(componentProps, props)} /> }`,
+    },
+    {
+      name: 'accepts props previously merged with mergeProps',
+      code: `
+        function Example() {
+          const mergedProps = mergeProps(componentProps, props)
+          return <button {...mergedProps} />
+        }
+      `,
+    },
+    {
+      name: 'ignores elements without spread props',
+      code: `function Example() { return <button type="button" /> }`,
+    },
+    {
+      name: 'ignores a component that only forwards consumer props',
+      code: `function Example(props) { return <button {...props} /> }`,
+    },
+    {
+      name: 'ignores a component that forwards consumer props and composes a ref separately',
+      code: `const Example = React.forwardRef((props, ref) => <button {...props} ref={ref} />)`,
+    },
+    {
+      name: 'ignores a component that only forwards props to a custom component',
+      code: `function Example(props) { return <Button {...props} /> }`,
+    },
+    {
+      name: 'ignores spread props on nested elements',
+      code: `function Example() { return <div><button {...props} /></div> }`,
+    },
+    {
+      name: 'ignores spread props inside a root fragment',
+      code: `function Example() { return <><button {...props} /></> }`,
+    },
+    {
+      name: 'ignores spread props on elements nested in conditional content',
+      code: `function Example() { return <div>{condition ? <button {...props} /> : null}</div> }`,
+    },
+    {
+      name: 'ignores spread props on elements nested in mapped content',
+      code: `function Example() { return <ul>{items.map(item => <li {...item} />)}</ul> }`,
+    },
+    {
+      name: 'ignores spread props on elements nested in a render prop',
+      code: `function Example() { return <Component render={() => <button {...props} />} /> }`,
+    },
+    {
+      name: 'ignores object spread expressions outside JSX',
+      code: `
+        const copiedProps = {...props}
+        const example = <button type="button" />
+      `,
+    },
+    {
+      name: 'ignores JSX assigned outside a component',
+      code: `const example = <button {...props} />`,
+    },
+    {
+      name: 'ignores JSX returned by a lowercase helper',
+      code: `function renderButton() { return <button {...props} /> }`,
+    },
+    {
+      name: 'ignores JSX returned by an unrelated callback',
+      code: `const buttons = items.map(props => <button {...props} />)`,
+    },
+    {
+      name: 'ignores component roots in test files',
+      filename: 'Example.test.jsx',
+      code: `function Example() { return <button {...props} /> }`,
+    },
+    {
+      name: 'ignores component roots in story files',
+      filename: 'Example.stories.jsx',
+      code: `function Example() { return <button {...props} /> }`,
+    },
+    {
+      name: 'ignores component roots in test directories',
+      filename: '__tests__/Example.jsx',
+      code: `function Example() { return <button {...props} /> }`,
+    },
+  ],
+  invalid: [
+    {
+      name: 'reports direct props spread on a function component root',
+      code: `function Example(props) { return <button {...props} type="button" /> }`,
+      errors: [{messageId: 'preferMergeProps'}],
+    },
+    {
+      name: 'reports rest props composed with an explicit handler',
+      code: `
+        function Example({onClick, ...rest}) {
+          return <button {...rest} type="button" onClick={event => onClick?.(event)} />
+        }
+      `,
+      errors: [{messageId: 'preferMergeProps'}],
+    },
+    {
+      name: 'reports each unmerged spread on a component root',
+      code: `function Example() { return <button {...componentProps} {...props} /> }`,
+      errors: [{messageId: 'preferMergeProps'}, {messageId: 'preferMergeProps'}],
+    },
+    {
+      name: 'reports component roots in separate return branches',
+      code: `
+        function Example({foo, ...rest}) {
+          if (foo) {
+            return <a {...rest} href="#" />
+          }
+          return <button {...rest} type="button" />
+        }
+      `,
+      errors: [{messageId: 'preferMergeProps'}, {messageId: 'preferMergeProps'}],
+    },
+    {
+      name: 'reports component roots in conditional expression branches',
+      code: `function Example() { return condition ? <button type="button" {...props} /> : <a href="#" {...props} /> }`,
+      errors: [{messageId: 'preferMergeProps'}, {messageId: 'preferMergeProps'}],
+    },
+    {
+      name: 'reports unmerged props on a root custom component',
+      code: `function Example() { return <Button variant="primary" {...props} /> }`,
+      errors: [{messageId: 'preferMergeProps'}],
+    },
+    {
+      name: 'reports unmerged props on a root member component',
+      code: `function Example() { return <ActionList.Item role="menuitem" {...props} /> }`,
+      errors: [{messageId: 'preferMergeProps'}],
+    },
+    {
+      name: 'reports spread props returned from a function call',
+      code: `function Example() { return <button type="button" {...getProps()} /> }`,
+      errors: [{messageId: 'preferMergeProps'}],
+    },
+    {
+      name: 'reports props copied into an object expression',
+      code: `function Example() { return <button type="button" {...{...props}} /> }`,
+      errors: [{messageId: 'preferMergeProps'}],
+    },
+    {
+      name: 'reports only the unmerged spread alongside merged props',
+      code: `function Example() { return <button {...mergeProps(componentProps, props)} {...otherProps} /> }`,
+      errors: [{messageId: 'preferMergeProps'}],
+    },
+    {
+      name: 'reports props on component roots in logical expressions',
+      code: `function Example() { return condition && <button type="button" {...props} /> }`,
+      errors: [{messageId: 'preferMergeProps'}],
+    },
+    {
+      name: 'reports props on a concise arrow component root',
+      code: `const Example = props => <button type="button" {...props} />`,
+      errors: [{messageId: 'preferMergeProps'}],
+    },
+    {
+      name: 'reports props on a forwardRef component root',
+      code: `const Example = React.forwardRef((props, ref) => <button type="button" {...props} ref={ref} />)`,
+      errors: [{messageId: 'preferMergeProps'}],
+    },
+    {
+      name: 'reports props on an asserted forwardRef component root',
+      code: `
+        const Example = React.forwardRef(
+          (props, ref) => <button type="button" {...props} ref={ref} />
+        ) as PolymorphicForwardRefComponent
+      `,
+      errors: [{messageId: 'preferMergeProps'}],
+    },
+    {
+      name: 'reports props on a forwardRef component root using satisfies',
+      code: `
+        const Example = React.forwardRef(
+          (props, ref) => <button type="button" {...props} ref={ref} />
+        ) satisfies PolymorphicForwardRefComponent
+      `,
+      errors: [{messageId: 'preferMergeProps'}],
+    },
+    {
+      name: 'reports props on a class component root',
+      code: `class Example extends React.Component { render() { return <button type="button" {...this.props} /> } }`,
+      errors: [{messageId: 'preferMergeProps'}],
+    },
+  ],
+})
diff --git a/packages/eslint-config/src/rules/preferMergeProps.ts b/packages/eslint-config/src/rules/preferMergeProps.ts
new file mode 100644
index 00000000000..34a2a638981
--- /dev/null
+++ b/packages/eslint-config/src/rules/preferMergeProps.ts
@@ -0,0 +1,294 @@
+import {ASTUtils, type TSESLint, type TSESTree} from '@typescript-eslint/utils'
+
+type MessageIds = 'preferMergeProps'
+
+const preferMergeProps: TSESLint.RuleModule<MessageIds> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Require spread props on component root elements to use mergeProps',
+    },
+    messages: {
+      preferMergeProps:
+        'Spread props on a component root element with mergeProps so component and consumer props are merged intentionally.',
+    },
+    schema: [],
+  },
+  create(context) {
+    const {sourceCode} = context
+
+    if (isTestOrStoryFile(context.filename)) {
+      return {}
+    }
+
+    return {
+      JSXOpeningElement(node) {
+        if (!isComponentRoot(node.parent) || !hasPropsToMerge(node)) {
+          return
+        }
+
+        for (const attribute of node.attributes) {
+          if (
+            attribute.type === 'JSXSpreadAttribute' &&
+            !isMergedProps(attribute.argument, sourceCode.getScope(attribute))
+          ) {
+            context.report({
+              node: attribute,
+              messageId: 'preferMergeProps',
+            })
+          }
+        }
+      },
+    }
+  },
+}
+
+function hasPropsToMerge(node: TSESTree.JSXOpeningElement): boolean {
+  const spreadCount = node.attributes.filter(attribute => attribute.type === 'JSXSpreadAttribute').length
+  if (spreadCount > 1) {
+    return true
+  }
+
+  return node.attributes.some(attribute => {
+    return (
+      attribute.type === 'JSXAttribute' &&
+      attribute.name.type === 'JSXIdentifier' &&
+      attribute.name.name !== 'key' &&
+      attribute.name.name !== 'ref'
+    )
+  })
+}
+
+function isTestOrStoryFile(filename: string): boolean {
+  const normalizedFilename = filename.replaceAll('\\', '/')
+  return (
+    /(?:^|\/)__(?:tests|stories)__(?:\/|$)/u.test(normalizedFilename) ||
+    /\.(?:spec|test|stories|story)\.[cm]?[jt]sx?$/u.test(normalizedFilename)
+  )
+}
+
+function isComponentRoot(element: TSESTree.JSXElement): boolean {
+  let expression: TSESTree.Node = element
+
+  for (;;) {
+    const parent: TSESTree.Node = expression.parent
+
+    if (
+      parent.type === 'ConditionalExpression' &&
+      (parent.consequent === expression || parent.alternate === expression)
+    ) {
+      expression = parent
+      continue
+    }
+
+    if (parent.type === 'LogicalExpression' && parent.right === expression) {
+      expression = parent
+      continue
+    }
+
+    if (isTypeScriptWrapper(parent)) {
+      expression = parent
+      continue
+    }
+
+    if (parent.type === 'ReturnStatement' && parent.argument === expression) {
+      return isReturnedByComponent(parent)
+    }
+
+    if (parent.type === 'ArrowFunctionExpression' && parent.body === expression) {
+      return isComponentFunction(parent)
+    }
+
+    if (parent.type === 'JSXElement' || parent.type === 'JSXFragment') {
+      return false
+    }
+
+    return false
+  }
+}
+
+function isTypeScriptWrapper(
+  node: TSESTree.Node,
+): node is
+  | TSESTree.TSAsExpression
+  | TSESTree.TSNonNullExpression
+  | TSESTree.TSSatisfiesExpression
+  | TSESTree.TSTypeAssertion {
+  return (
+    node.type === 'TSAsExpression' ||
+    node.type === 'TSNonNullExpression' ||
+    node.type === 'TSSatisfiesExpression' ||
+    node.type === 'TSTypeAssertion'
+  )
+}
+
+function isReturnedByComponent(statement: TSESTree.ReturnStatement): boolean {
+  let ancestor = statement.parent
+
+  while (ancestor.type !== 'Program') {
+    if (isFunction(ancestor)) {
+      return isComponentFunction(ancestor)
+    }
+    ancestor = ancestor.parent
+  }
+
+  return false
+}
+
+function isFunction(node: TSESTree.Node): node is ComponentFunction {
+  return (
+    node.type === 'ArrowFunctionExpression' || node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression'
+  )
+}
+
+type ComponentFunction = TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression
+
+function isComponentFunction(node: ComponentFunction): boolean {
+  const name = getFunctionName(node)
+  if (name !== null) {
+    return isComponentName(name)
+  }
+
+  if (node.parent.type === 'ExportDefaultDeclaration') {
+    return true
+  }
+
+  return isWrappedComponent(node)
+}
+
+function getFunctionName(node: ComponentFunction): string | null {
+  if (node.parent.type === 'VariableDeclarator' && node.parent.init === node && node.parent.id.type === 'Identifier') {
+    return node.parent.id.name
+  }
+
+  if (
+    node.parent.type === 'AssignmentExpression' &&
+    node.parent.right === node &&
+    node.parent.left.type === 'Identifier'
+  ) {
+    return node.parent.left.name
+  }
+
+  if (node.type !== 'ArrowFunctionExpression' && node.id !== null) {
+    return node.id.name
+  }
+
+  if (
+    node.type === 'FunctionExpression' &&
+    node.parent.type === 'MethodDefinition' &&
+    node.parent.value === node &&
+    node.parent.key.type === 'Identifier' &&
+    node.parent.key.name === 'render'
+  ) {
+    return getClassName(node.parent.parent.parent)
+  }
+
+  return null
+}
+
+function getClassName(node: TSESTree.ClassDeclaration | TSESTree.ClassExpression): string | null {
+  if (node.id !== null) {
+    return node.id.name
+  }
+
+  if (node.parent.type === 'VariableDeclarator' && node.parent.init === node && node.parent.id.type === 'Identifier') {
+    return node.parent.id.name
+  }
+
+  if (node.parent.type === 'ExportDefaultDeclaration') {
+    return 'DefaultExport'
+  }
+
+  return null
+}
+
+function isWrappedComponent(node: ComponentFunction): boolean {
+  let expression: TSESTree.Node = node
+
+  for (;;) {
+    const parent: TSESTree.Node = expression.parent
+
+    if (isTypeScriptWrapper(parent)) {
+      expression = parent
+      continue
+    }
+
+    if (
+      parent.type === 'CallExpression' &&
+      parent.arguments.includes(expression as TSESTree.Expression) &&
+      isComponentWrapper(parent.callee)
+    ) {
+      expression = parent
+      continue
+    }
+
+    break
+  }
+
+  return (
+    (expression.parent.type === 'VariableDeclarator' &&
+      expression.parent.init === expression &&
+      expression.parent.id.type === 'Identifier' &&
+      isComponentName(expression.parent.id.name)) ||
+    expression.parent.type === 'ExportDefaultDeclaration'
+  )
+}
+
+function isComponentWrapper(callee: TSESTree.Expression): boolean {
+  if (callee.type === 'Identifier') {
+    return callee.name === 'forwardRef' || callee.name === 'fixedForwardRef' || callee.name === 'memo'
+  }
+
+  return (
+    callee.type === 'MemberExpression' &&
+    !callee.computed &&
+    callee.property.type === 'Identifier' &&
+    (callee.property.name === 'forwardRef' || callee.property.name === 'memo')
+  )
+}
+
+function isComponentName(name: string): boolean {
+  return /^[A-Z]/u.test(name)
+}
+
+function isMergedProps(argument: TSESTree.Expression, scope: TSESLint.Scope.Scope): boolean {
+  if (isMergePropsCall(argument)) {
+    return true
+  }
+
+  if (argument.type !== 'Identifier') {
+    return false
+  }
+
+  const variable = ASTUtils.findVariable(scope, argument)
+  return (
+    variable?.defs.some(definition => {
+      return (
+        definition.type === 'Variable' &&
+        definition.parent.kind === 'const' &&
+        definition.node.init !== null &&
+        isMergePropsCall(definition.node.init)
+      )
+    }) ?? false
+  )
+}
+
+function isMergePropsCall(argument: TSESTree.Expression): boolean {
+  if (argument.type !== 'CallExpression') {
+    return false
+  }
+
+  const {callee} = argument
+  if (callee.type === 'Identifier') {
+    return callee.name === 'mergeProps'
+  }
+
+  return (
+    callee.type === 'MemberExpression' &&
+    !callee.computed &&
+    callee.property.type === 'Identifier' &&
+    callee.property.name === 'mergeProps'
+  )
+}
+
+export {preferMergeProps}
diff --git a/packages/eslint-config/tsconfig.json b/packages/eslint-config/tsconfig.json
new file mode 100644
index 00000000000..02e8975d4d9
--- /dev/null
+++ b/packages/eslint-config/tsconfig.json
@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "allowImportingTsExtensions": true
+  },
+  "include": ["src", "vitest.config.ts"]
+}
diff --git a/packages/eslint-config/vitest.config.ts b/packages/eslint-config/vitest.config.ts
new file mode 100644
index 00000000000..6c7353fc4e0
--- /dev/null
+++ b/packages/eslint-config/vitest.config.ts
@@ -0,0 +1,7 @@
+import {defineConfig} from '@primer/vitest-config/config'
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+  },
+})
diff --git a/script/merge-props-migration-status.mts b/script/merge-props-migration-status.mts
new file mode 100644
index 00000000000..5e5d08675be
--- /dev/null
+++ b/script/merge-props-migration-status.mts
@@ -0,0 +1,65 @@
+import path from 'node:path'
+import {ESLint} from 'eslint'
+
+const directory = path.resolve(import.meta.dirname, '..')
+const ruleId = 'primer/prefer-merge-props'
+const eslint = new ESLint({
+  cwd: directory,
+  overrideConfig: [
+    {
+      rules: {
+        [ruleId]: 'error',
+      },
+    },
+  ],
+})
+const results = await eslint.lintFiles(['packages/react/src/**/*.{ts,tsx}'])
+const fatalMessages = results.flatMap(result => {
+  return result.messages
+    .filter(message => message.fatal)
+    .map(message => `${result.filePath}:${message.line} ${message.message}`)
+})
+
+if (fatalMessages.length > 0) {
+  throw new Error(`Unable to generate the mergeProps migration report:\n${fatalMessages.join('\n')}`)
+}
+
+const affectedResults = results.filter(result => {
+  return result.messages.some(message => message.ruleId === ruleId)
+})
+const violationCount = affectedResults.reduce((count, result) => {
+  return count + result.messages.filter(message => message.ruleId === ruleId).length
+}, 0)
+
+write(`
+# mergeProps Migration
+
+This report tracks component roots that combine authored props with unmerged spread props.
+
+## Status
+
+**Unmerged component root prop spreads to migrate:** ${violationCount}
+
+**Affected files:** ${affectedResults.length} of ${results.length}
+`)
+
+write(`
+## Affected Files (${affectedResults.length})
+
+| Filepath | Locations | Violations |
+| :------- | :-------- | :--------- |`)
+
+for (const result of affectedResults) {
+  const relativePath = path.relative(directory, result.filePath)
+  const messages = result.messages.filter(message => message.ruleId === ruleId)
+  const locations = messages.map(
+    message => `[L${message.line}](https://github.com/primer/react/blob/main/${relativePath}#L${message.line})`,
+  )
+  const link = `[\`${relativePath}\`](https://github.com/primer/react/blob/main/${relativePath})`
+
+  write(`| ${link} | ${locations.join(', ')} | ${messages.length} |`)
+}
+
+function write(value: string): void {
+  process.stdout.write(`${value}\n`)
+}