From 979cf3fc2a8597b04ae9db79af0840b5b3370fce Mon Sep 17 00:00:00 2001
From: TkDodo <dominik.dorfmeister@sentry.io>
Date: Fri, 10 Apr 2026 17:13:31 +0200
Subject: [PATCH 01/14] feat(eslint): no-unnecessary-use-callback

---
 eslint.config.ts                              |   1 +
 static/eslint/eslintPluginSentry/index.ts     |   2 +
 .../no-unnecessary-use-callback.spec.ts       | 186 ++++++++++++++++++
 .../no-unnecessary-use-callback.ts            | 162 +++++++++++++++
 4 files changed, 351 insertions(+)
 create mode 100644 static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
 create mode 100644 static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts

diff --git a/eslint.config.ts b/eslint.config.ts
index 3fb04f947cf187..c7558fa5d6ede6 100644
--- a/eslint.config.ts
+++ b/eslint.config.ts
@@ -461,6 +461,7 @@ export default typescript.config([
       '@sentry/no-dynamic-translations': 'error',
       '@sentry/no-static-translations': 'error',
       '@sentry/no-styled-shortcut': 'error',
+      '@sentry/no-unnecessary-use-callback': 'error',
     },
   },
   {
diff --git a/static/eslint/eslintPluginSentry/index.ts b/static/eslint/eslintPluginSentry/index.ts
index 5cb811d210125d..2aad65f698f4f6 100644
--- a/static/eslint/eslintPluginSentry/index.ts
+++ b/static/eslint/eslintPluginSentry/index.ts
@@ -4,6 +4,7 @@ import {noDynamicTranslations} from './no-dynamic-translations';
 import {noStaticTranslations} from './no-static-translations';
 import {noStyledShortcut} from './no-styled-shortcut';
 import {noUnnecessaryTypeAnnotation} from './no-unnecessary-type-annotation';
+import {noUnnecessaryUseCallback} from './no-unnecessary-use-callback';
 
 export const rules = {
   'no-default-exports': noDefaultExports,
@@ -12,4 +13,5 @@ export const rules = {
   'no-static-translations': noStaticTranslations,
   'no-styled-shortcut': noStyledShortcut,
   'no-unnecessary-type-annotation': noUnnecessaryTypeAnnotation,
+  'no-unnecessary-use-callback': noUnnecessaryUseCallback,
 };
diff --git a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
new file mode 100644
index 00000000000000..5a854fd781b167
--- /dev/null
+++ b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
@@ -0,0 +1,186 @@
+import {RuleTester} from '@typescript-eslint/rule-tester';
+
+import {noUnnecessaryUseCallback} from './no-unnecessary-use-callback';
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parserOptions: {
+      ecmaFeatures: {jsx: true},
+    },
+  },
+});
+
+ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
+  valid: [
+    {
+      name: 'useCallback passed directly to custom component',
+      code: `
+        const fn = useCallback(() => {
+          console.log('click');
+        }, []);
+        <MyComponent onClick={fn} />
+      `,
+    },
+    {
+      name: 'regular function passed to intrinsic element',
+      code: `
+        const fn = () => console.log('click');
+        <button onClick={fn} />
+      `,
+    },
+    {
+      name: 'regular function wrapped in arrow on intrinsic element',
+      code: `
+        const fn = () => console.log('click');
+        <button onClick={() => fn()} />
+      `,
+    },
+    {
+      name: 'inline arrow on intrinsic element without useCallback',
+      code: `
+        <button onClick={() => console.log('click')} />
+      `,
+    },
+    {
+      name: 'useCallback used in dependency array',
+      code: `
+        const fn = useCallback(() => {}, []);
+        useEffect(() => { fn() }, [fn]);
+      `,
+    },
+    {
+      name: 'useCallback result used in non-JSX context',
+      code: `
+        const fn = useCallback(() => {}, []);
+        someFunction(fn);
+      `,
+    },
+    {
+      name: 'arrow wrapping a call to a different function',
+      code: `
+        const fn = useCallback(() => {}, []);
+        <button onClick={() => otherFn()} />
+      `,
+    },
+    {
+      name: 'useCallback passed directly to namespaced custom component',
+      code: `
+        const fn = useCallback(() => {}, []);
+        <Namespace.Component onClick={fn} />
+      `,
+    },
+    {
+      name: 'arrow body calls non-useCallback function',
+      code: `
+        const fn = useCallback(() => {}, []);
+        <button onClick={() => { doSomethingElse(); }} />
+      `,
+    },
+    {
+      name: 'useCallback justified by custom component usage alongside direct invocation',
+      code: `
+        const fn = useCallback(() => {}, []);
+        <><MyComponent onClick={fn} /><button onClick={() => fn()} /></>
+      `,
+    },
+    {
+      name: 'useCallback justified by custom component usage alongside intrinsic element',
+      code: `
+        const fn = useCallback(() => {}, []);
+        <><MyComponent onClick={fn} /><button onClick={fn} /></>
+      `,
+    },
+    {
+      name: 'useCallback passed as callback ref to intrinsic element',
+      code: `
+        const fn = useCallback((node) => {
+          if (node) node.focus();
+        }, []);
+        <input ref={fn} />
+      `,
+    },
+  ],
+
+  invalid: [
+    {
+      name: 'arrow wrap on intrinsic element',
+      code: `
+        const fn = useCallback(() => {
+          console.log('click');
+        }, []);
+        <button onClick={() => fn()} />
+      `,
+      errors: [{messageId: 'directlyInvoked', data: {name: 'fn'}}],
+    },
+    {
+      name: 'arrow wrap on custom component',
+      code: `
+        const fn = useCallback(() => {
+          console.log('click');
+        }, []);
+        <MyComponent onClick={() => fn()} />
+      `,
+      errors: [{messageId: 'directlyInvoked', data: {name: 'fn'}}],
+    },
+    {
+      name: 'arrow wrap with argument forwarding',
+      code: `
+        const fn = useCallback((e) => {
+          console.log(e);
+        }, []);
+        <button onClick={(e) => fn(e)} />
+      `,
+      errors: [{messageId: 'directlyInvoked', data: {name: 'fn'}}],
+    },
+    {
+      name: 'direct reference on <button>',
+      code: `
+        const fn = useCallback((e) => {
+          console.log('click');
+        }, []);
+        <button onClick={fn} />
+      `,
+      errors: [{messageId: 'intrinsicElement', data: {name: 'fn', element: 'button'}}],
+    },
+    {
+      name: 'direct reference on <div>',
+      code: `
+        const fn = useCallback(() => {}, []);
+        <div onMouseEnter={fn} />
+      `,
+      errors: [{messageId: 'intrinsicElement', data: {name: 'fn', element: 'div'}}],
+    },
+    {
+      name: 'direct reference on <input>',
+      code: `
+        const fn = useCallback(() => {}, []);
+        <input onChange={fn} />
+      `,
+      errors: [{messageId: 'intrinsicElement', data: {name: 'fn', element: 'input'}}],
+    },
+    {
+      name: 'direct reference on <a>',
+      code: `
+        const fn = useCallback(() => {}, []);
+        <a onClick={fn} />
+      `,
+      errors: [{messageId: 'intrinsicElement', data: {name: 'fn', element: 'a'}}],
+    },
+    {
+      name: 'arrow wrap with multiple arguments',
+      code: `
+        const handler = useCallback((a, b) => {}, []);
+        <button onClick={(a, b) => handler(a, b)} />
+      `,
+      errors: [{messageId: 'directlyInvoked', data: {name: 'handler'}}],
+    },
+    {
+      name: 'useCallback called inside block-body arrow with additional logic',
+      code: `
+        const fn = useCallback(() => {}, []);
+        <button onClick={() => { fn(); doSomethingElse(); }} />
+      `,
+      errors: [{messageId: 'directlyInvoked', data: {name: 'fn'}}],
+    },
+  ],
+});
diff --git a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
new file mode 100644
index 00000000000000..9f4a34626f50aa
--- /dev/null
+++ b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
@@ -0,0 +1,162 @@
+import {AST_NODE_TYPES, ESLintUtils, type TSESTree} from '@typescript-eslint/utils';
+
+interface PendingReport {
+  data: Record<string, string>;
+  messageId: 'directlyInvoked' | 'intrinsicElement';
+  node: TSESTree.Node;
+}
+
+export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow useCallback where it provides no benefit: when the result is directly invoked (defeating memoization) or passed to intrinsic elements (which are not memoized).',
+    },
+    schema: [],
+    messages: {
+      directlyInvoked:
+        'Unnecessary useCallback. `{{name}}` is immediately called inside an inline arrow function, so the stable reference from useCallback is never used.',
+      intrinsicElement:
+        'Unnecessary useCallback. `{{name}}` is passed to the intrinsic element `<{{element}}>`, which is not memoized.',
+    },
+  },
+  create(context) {
+    const useCallbackBindings = new Set<string>();
+    // Bindings that have at least one usage where memoization is justified
+    // (e.g. passed directly to a custom component)
+    const justifiedBindings = new Set<string>();
+    // Potential violations collected during traversal, reported at Program:exit
+    const pendingReports = new Map<string, PendingReport[]>();
+
+    function addPendingReport(name: string, report: PendingReport) {
+      let reports = pendingReports.get(name);
+      if (!reports) {
+        reports = [];
+        pendingReports.set(name, reports);
+      }
+      reports.push(report);
+    }
+
+    /**
+     * Walks an AST node looking for a CallExpression whose callee is a
+     * tracked useCallback binding. Returns the binding name if found.
+     * Uses visitorKeys to avoid circular parent references.
+     */
+    function findCallToBinding(node: TSESTree.Node): string | null {
+      if (
+        node.type === AST_NODE_TYPES.CallExpression &&
+        node.callee.type === AST_NODE_TYPES.Identifier &&
+        useCallbackBindings.has(node.callee.name)
+      ) {
+        return node.callee.name;
+      }
+      const keys = context.sourceCode.visitorKeys[node.type] ?? [];
+      for (const key of keys) {
+        const child = node[key as keyof typeof node] as
+          | TSESTree.Node
+          | TSESTree.Node[]
+          | null
+          | undefined;
+        if (Array.isArray(child)) {
+          for (const item of child) {
+            if (item) {
+              const result = findCallToBinding(item);
+              if (result) {
+                return result;
+              }
+            }
+          }
+        } else if (child) {
+          const result = findCallToBinding(child);
+          if (result) {
+            return result;
+          }
+        }
+      }
+      return null;
+    }
+
+    return {
+      VariableDeclarator(node) {
+        if (node.id.type !== AST_NODE_TYPES.Identifier) {
+          return;
+        }
+        if (
+          node.init?.type === AST_NODE_TYPES.CallExpression &&
+          node.init.callee.type === AST_NODE_TYPES.Identifier &&
+          node.init.callee.name === 'useCallback'
+        ) {
+          useCallbackBindings.add(node.id.name);
+        }
+      },
+
+      JSXAttribute(node) {
+        if (node.value?.type !== AST_NODE_TYPES.JSXExpressionContainer) {
+          return;
+        }
+
+        const expr = node.value.expression;
+
+        // Case 1: Arrow function that calls a useCallback binding in its body
+        // e.g. onClick={() => fn()}, onClick={(e) => fn(e)},
+        //      onClick={() => { fn(); doSomethingElse(); }}
+        if (expr.type === AST_NODE_TYPES.ArrowFunctionExpression) {
+          const calledBinding = findCallToBinding(expr.body);
+          if (calledBinding) {
+            addPendingReport(calledBinding, {
+              node: node.value,
+              messageId: 'directlyInvoked',
+              data: {name: calledBinding},
+            });
+            return;
+          }
+        }
+
+        // Exception: ref props are callback refs that benefit from memoization
+        const propName =
+          node.name.type === AST_NODE_TYPES.JSXIdentifier ? node.name.name : null;
+        if (propName === 'ref') {
+          return;
+        }
+
+        if (
+          expr.type === AST_NODE_TYPES.Identifier &&
+          useCallbackBindings.has(expr.name)
+        ) {
+          const openingElement = node.parent;
+          if (openingElement.type !== AST_NODE_TYPES.JSXOpeningElement) {
+            return;
+          }
+          const tagName = openingElement.name;
+
+          if (
+            tagName.type === AST_NODE_TYPES.JSXIdentifier &&
+            tagName.name[0] === tagName.name[0]?.toLowerCase()
+          ) {
+            // Case 2: Direct reference on an intrinsic element
+            addPendingReport(expr.name, {
+              node: node.value,
+              messageId: 'intrinsicElement',
+              data: {name: expr.name, element: tagName.name},
+            });
+          } else {
+            // Passed directly to a custom component — memoization is justified
+            justifiedBindings.add(expr.name);
+          }
+        }
+      },
+
+      'Program:exit'() {
+        for (const [name, reports] of pendingReports) {
+          if (justifiedBindings.has(name)) {
+            continue;
+          }
+          for (const report of reports) {
+            context.report(report);
+          }
+        }
+      },
+    };
+  },
+});

From 976a673164ccc628aee870f55272a3ac1556905f Mon Sep 17 00:00:00 2001
From: TkDodo <dominik.dorfmeister@sentry.io>
Date: Fri, 10 Apr 2026 17:26:39 +0200
Subject: [PATCH 02/14] only report on creation site

---
 .../no-unnecessary-use-callback.spec.ts       | 18 +++---
 .../no-unnecessary-use-callback.ts            | 56 +++++++------------
 2 files changed, 28 insertions(+), 46 deletions(-)

diff --git a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
index 5a854fd781b167..7b67a5662d97d6 100644
--- a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
+++ b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
@@ -110,7 +110,7 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
         }, []);
         <button onClick={() => fn()} />
       `,
-      errors: [{messageId: 'directlyInvoked', data: {name: 'fn'}}],
+      errors: [{messageId: 'unnecessaryUseCallback', data: {name: 'fn'}}],
     },
     {
       name: 'arrow wrap on custom component',
@@ -120,7 +120,7 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
         }, []);
         <MyComponent onClick={() => fn()} />
       `,
-      errors: [{messageId: 'directlyInvoked', data: {name: 'fn'}}],
+      errors: [{messageId: 'unnecessaryUseCallback', data: {name: 'fn'}}],
     },
     {
       name: 'arrow wrap with argument forwarding',
@@ -130,7 +130,7 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
         }, []);
         <button onClick={(e) => fn(e)} />
       `,
-      errors: [{messageId: 'directlyInvoked', data: {name: 'fn'}}],
+      errors: [{messageId: 'unnecessaryUseCallback', data: {name: 'fn'}}],
     },
     {
       name: 'direct reference on <button>',
@@ -140,7 +140,7 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
         }, []);
         <button onClick={fn} />
       `,
-      errors: [{messageId: 'intrinsicElement', data: {name: 'fn', element: 'button'}}],
+      errors: [{messageId: 'unnecessaryUseCallback', data: {name: 'fn'}}],
     },
     {
       name: 'direct reference on <div>',
@@ -148,7 +148,7 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
         const fn = useCallback(() => {}, []);
         <div onMouseEnter={fn} />
       `,
-      errors: [{messageId: 'intrinsicElement', data: {name: 'fn', element: 'div'}}],
+      errors: [{messageId: 'unnecessaryUseCallback', data: {name: 'fn'}}],
     },
     {
       name: 'direct reference on <input>',
@@ -156,7 +156,7 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
         const fn = useCallback(() => {}, []);
         <input onChange={fn} />
       `,
-      errors: [{messageId: 'intrinsicElement', data: {name: 'fn', element: 'input'}}],
+      errors: [{messageId: 'unnecessaryUseCallback', data: {name: 'fn'}}],
     },
     {
       name: 'direct reference on <a>',
@@ -164,7 +164,7 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
         const fn = useCallback(() => {}, []);
         <a onClick={fn} />
       `,
-      errors: [{messageId: 'intrinsicElement', data: {name: 'fn', element: 'a'}}],
+      errors: [{messageId: 'unnecessaryUseCallback', data: {name: 'fn'}}],
     },
     {
       name: 'arrow wrap with multiple arguments',
@@ -172,7 +172,7 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
         const handler = useCallback((a, b) => {}, []);
         <button onClick={(a, b) => handler(a, b)} />
       `,
-      errors: [{messageId: 'directlyInvoked', data: {name: 'handler'}}],
+      errors: [{messageId: 'unnecessaryUseCallback', data: {name: 'handler'}}],
     },
     {
       name: 'useCallback called inside block-body arrow with additional logic',
@@ -180,7 +180,7 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
         const fn = useCallback(() => {}, []);
         <button onClick={() => { fn(); doSomethingElse(); }} />
       `,
-      errors: [{messageId: 'directlyInvoked', data: {name: 'fn'}}],
+      errors: [{messageId: 'unnecessaryUseCallback', data: {name: 'fn'}}],
     },
   ],
 });
diff --git a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
index 9f4a34626f50aa..7e490bec6f35ed 100644
--- a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
+++ b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
@@ -1,11 +1,5 @@
 import {AST_NODE_TYPES, ESLintUtils, type TSESTree} from '@typescript-eslint/utils';
 
-interface PendingReport {
-  data: Record<string, string>;
-  messageId: 'directlyInvoked' | 'intrinsicElement';
-  node: TSESTree.Node;
-}
-
 export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
   meta: {
     type: 'suggestion',
@@ -15,28 +9,18 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
     },
     schema: [],
     messages: {
-      directlyInvoked:
-        'Unnecessary useCallback. `{{name}}` is immediately called inside an inline arrow function, so the stable reference from useCallback is never used.',
-      intrinsicElement:
-        'Unnecessary useCallback. `{{name}}` is passed to the intrinsic element `<{{element}}>`, which is not memoized.',
+      unnecessaryUseCallback:
+        'Unnecessary useCallback. `{{name}}` is only used in contexts where memoization provides no benefit.',
     },
   },
   create(context) {
-    const useCallbackBindings = new Set<string>();
+    // Maps binding name to the useCallback() CallExpression node
+    const useCallbackBindings = new Map<string, TSESTree.CallExpression>();
     // Bindings that have at least one usage where memoization is justified
     // (e.g. passed directly to a custom component)
     const justifiedBindings = new Set<string>();
-    // Potential violations collected during traversal, reported at Program:exit
-    const pendingReports = new Map<string, PendingReport[]>();
-
-    function addPendingReport(name: string, report: PendingReport) {
-      let reports = pendingReports.get(name);
-      if (!reports) {
-        reports = [];
-        pendingReports.set(name, reports);
-      }
-      reports.push(report);
-    }
+    // Bindings with at least one flaggable usage, keyed by name
+    const flaggedBindings = new Set<string>();
 
     /**
      * Walks an AST node looking for a CallExpression whose callee is a
@@ -47,7 +31,8 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
       if (
         node.type === AST_NODE_TYPES.CallExpression &&
         node.callee.type === AST_NODE_TYPES.Identifier &&
-        useCallbackBindings.has(node.callee.name)
+        useCallbackBindings.has(node.callee.name) &&
+        !justifiedBindings.has(node.callee.name)
       ) {
         return node.callee.name;
       }
@@ -87,7 +72,7 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
           node.init.callee.type === AST_NODE_TYPES.Identifier &&
           node.init.callee.name === 'useCallback'
         ) {
-          useCallbackBindings.add(node.id.name);
+          useCallbackBindings.set(node.id.name, node.init);
         }
       },
 
@@ -104,11 +89,7 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
         if (expr.type === AST_NODE_TYPES.ArrowFunctionExpression) {
           const calledBinding = findCallToBinding(expr.body);
           if (calledBinding) {
-            addPendingReport(calledBinding, {
-              node: node.value,
-              messageId: 'directlyInvoked',
-              data: {name: calledBinding},
-            });
+            flaggedBindings.add(calledBinding);
             return;
           }
         }
@@ -135,11 +116,7 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
             tagName.name[0] === tagName.name[0]?.toLowerCase()
           ) {
             // Case 2: Direct reference on an intrinsic element
-            addPendingReport(expr.name, {
-              node: node.value,
-              messageId: 'intrinsicElement',
-              data: {name: expr.name, element: tagName.name},
-            });
+            flaggedBindings.add(expr.name);
           } else {
             // Passed directly to a custom component — memoization is justified
             justifiedBindings.add(expr.name);
@@ -148,12 +125,17 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
       },
 
       'Program:exit'() {
-        for (const [name, reports] of pendingReports) {
+        for (const name of flaggedBindings) {
           if (justifiedBindings.has(name)) {
             continue;
           }
-          for (const report of reports) {
-            context.report(report);
+          const callNode = useCallbackBindings.get(name);
+          if (callNode) {
+            context.report({
+              node: callNode,
+              messageId: 'unnecessaryUseCallback',
+              data: {name},
+            });
           }
         }
       },

From 50577057df6fe63a5a69ab4f1d1ca4fd02a880f8 Mon Sep 17 00:00:00 2001
From: TkDodo <dominik.dorfmeister@sentry.io>
Date: Fri, 10 Apr 2026 17:30:04 +0200
Subject: [PATCH 03/14] better messages

---
 .../no-unnecessary-use-callback.spec.ts       | 152 ++++++++++++------
 .../no-unnecessary-use-callback.ts            |  50 ++++--
 2 files changed, 140 insertions(+), 62 deletions(-)

diff --git a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
index 7b67a5662d97d6..e8909068d10ab4 100644
--- a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
+++ b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
@@ -104,83 +104,129 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
   invalid: [
     {
       name: 'arrow wrap on intrinsic element',
-      code: `
-        const fn = useCallback(() => {
-          console.log('click');
-        }, []);
-        <button onClick={() => fn()} />
-      `,
-      errors: [{messageId: 'unnecessaryUseCallback', data: {name: 'fn'}}],
+      code: `const fn = useCallback(() => { console.log('click'); }, []);
+<button onClick={() => fn()} />`,
+      errors: [
+        {
+          messageId: 'unnecessaryUseCallback',
+          data: {name: 'fn', usages: 'directly invoked in line 2'},
+        },
+      ],
     },
     {
       name: 'arrow wrap on custom component',
-      code: `
-        const fn = useCallback(() => {
-          console.log('click');
-        }, []);
-        <MyComponent onClick={() => fn()} />
-      `,
-      errors: [{messageId: 'unnecessaryUseCallback', data: {name: 'fn'}}],
+      code: `const fn = useCallback(() => { console.log('click'); }, []);
+<MyComponent onClick={() => fn()} />`,
+      errors: [
+        {
+          messageId: 'unnecessaryUseCallback',
+          data: {name: 'fn', usages: 'directly invoked in line 2'},
+        },
+      ],
     },
     {
       name: 'arrow wrap with argument forwarding',
-      code: `
-        const fn = useCallback((e) => {
-          console.log(e);
-        }, []);
-        <button onClick={(e) => fn(e)} />
-      `,
-      errors: [{messageId: 'unnecessaryUseCallback', data: {name: 'fn'}}],
+      code: `const fn = useCallback((e) => { console.log(e); }, []);
+<button onClick={(e) => fn(e)} />`,
+      errors: [
+        {
+          messageId: 'unnecessaryUseCallback',
+          data: {name: 'fn', usages: 'directly invoked in line 2'},
+        },
+      ],
     },
     {
       name: 'direct reference on <button>',
-      code: `
-        const fn = useCallback((e) => {
-          console.log('click');
-        }, []);
-        <button onClick={fn} />
-      `,
-      errors: [{messageId: 'unnecessaryUseCallback', data: {name: 'fn'}}],
+      code: `const fn = useCallback((e) => { console.log('click'); }, []);
+<button onClick={fn} />`,
+      errors: [
+        {
+          messageId: 'unnecessaryUseCallback',
+          data: {
+            name: 'fn',
+            usages: 'passed to intrinsic element <button> in line 2',
+          },
+        },
+      ],
     },
     {
       name: 'direct reference on <div>',
-      code: `
-        const fn = useCallback(() => {}, []);
-        <div onMouseEnter={fn} />
-      `,
-      errors: [{messageId: 'unnecessaryUseCallback', data: {name: 'fn'}}],
+      code: `const fn = useCallback(() => {}, []);
+<div onMouseEnter={fn} />`,
+      errors: [
+        {
+          messageId: 'unnecessaryUseCallback',
+          data: {
+            name: 'fn',
+            usages: 'passed to intrinsic element <div> in line 2',
+          },
+        },
+      ],
     },
     {
       name: 'direct reference on <input>',
-      code: `
-        const fn = useCallback(() => {}, []);
-        <input onChange={fn} />
-      `,
-      errors: [{messageId: 'unnecessaryUseCallback', data: {name: 'fn'}}],
+      code: `const fn = useCallback(() => {}, []);
+<input onChange={fn} />`,
+      errors: [
+        {
+          messageId: 'unnecessaryUseCallback',
+          data: {
+            name: 'fn',
+            usages: 'passed to intrinsic element <input> in line 2',
+          },
+        },
+      ],
     },
     {
       name: 'direct reference on <a>',
-      code: `
-        const fn = useCallback(() => {}, []);
-        <a onClick={fn} />
-      `,
-      errors: [{messageId: 'unnecessaryUseCallback', data: {name: 'fn'}}],
+      code: `const fn = useCallback(() => {}, []);
+<a onClick={fn} />`,
+      errors: [
+        {
+          messageId: 'unnecessaryUseCallback',
+          data: {
+            name: 'fn',
+            usages: 'passed to intrinsic element <a> in line 2',
+          },
+        },
+      ],
     },
     {
       name: 'arrow wrap with multiple arguments',
-      code: `
-        const handler = useCallback((a, b) => {}, []);
-        <button onClick={(a, b) => handler(a, b)} />
-      `,
-      errors: [{messageId: 'unnecessaryUseCallback', data: {name: 'handler'}}],
+      code: `const handler = useCallback((a, b) => {}, []);
+<button onClick={(a, b) => handler(a, b)} />`,
+      errors: [
+        {
+          messageId: 'unnecessaryUseCallback',
+          data: {name: 'handler', usages: 'directly invoked in line 2'},
+        },
+      ],
     },
     {
       name: 'useCallback called inside block-body arrow with additional logic',
-      code: `
-        const fn = useCallback(() => {}, []);
-        <button onClick={() => { fn(); doSomethingElse(); }} />
-      `,
-      errors: [{messageId: 'unnecessaryUseCallback', data: {name: 'fn'}}],
+      code: `const fn = useCallback(() => {}, []);
+<button onClick={() => { fn(); doSomethingElse(); }} />`,
+      errors: [
+        {
+          messageId: 'unnecessaryUseCallback',
+          data: {name: 'fn', usages: 'directly invoked in line 2'},
+        },
+      ],
+    },
+    {
+      name: 'multiple flagged usages reported together',
+      code: `const fn = useCallback(() => {}, []);
+<><button onClick={() => fn()} /><div onMouseEnter={fn} /></>`,
+      errors: [
+        {
+          messageId: 'unnecessaryUseCallback',
+          data: {
+            name: 'fn',
+            usages:
+              'directly invoked in line 2 and passed to intrinsic element <div> in line 2',
+          },
+        },
+      ],
     },
   ],
 });
diff --git a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
index 7e490bec6f35ed..ccf2bca2442ebc 100644
--- a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
+++ b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
@@ -1,5 +1,22 @@
 import {AST_NODE_TYPES, ESLintUtils, type TSESTree} from '@typescript-eslint/utils';
 
+interface UsageInfo {
+  line: number;
+  reason: 'directlyInvoked' | 'intrinsicElement';
+  element?: string;
+}
+
+function formatUsages(usages: UsageInfo[]): string {
+  return usages
+    .map(u => {
+      if (u.reason === 'directlyInvoked') {
+        return `directly invoked in line ${u.line}`;
+      }
+      return `passed to intrinsic element <${u.element}> in line ${u.line}`;
+    })
+    .join(' and ');
+}
+
 export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
   meta: {
     type: 'suggestion',
@@ -10,7 +27,7 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
     schema: [],
     messages: {
       unnecessaryUseCallback:
-        'Unnecessary useCallback. `{{name}}` is only used in contexts where memoization provides no benefit.',
+        'Unnecessary useCallback. `{{name}}` is only used in contexts where memoization provides no benefit. It is {{usages}}.',
     },
   },
   create(context) {
@@ -19,8 +36,17 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
     // Bindings that have at least one usage where memoization is justified
     // (e.g. passed directly to a custom component)
     const justifiedBindings = new Set<string>();
-    // Bindings with at least one flaggable usage, keyed by name
-    const flaggedBindings = new Set<string>();
+    // Collected flagged usages per binding
+    const flaggedUsages = new Map<string, UsageInfo[]>();
+
+    function addFlaggedUsage(name: string, usage: UsageInfo) {
+      let usages = flaggedUsages.get(name);
+      if (!usages) {
+        usages = [];
+        flaggedUsages.set(name, usages);
+      }
+      usages.push(usage);
+    }
 
     /**
      * Walks an AST node looking for a CallExpression whose callee is a
@@ -31,8 +57,7 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
       if (
         node.type === AST_NODE_TYPES.CallExpression &&
         node.callee.type === AST_NODE_TYPES.Identifier &&
-        useCallbackBindings.has(node.callee.name) &&
-        !justifiedBindings.has(node.callee.name)
+        useCallbackBindings.has(node.callee.name)
       ) {
         return node.callee.name;
       }
@@ -89,7 +114,10 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
         if (expr.type === AST_NODE_TYPES.ArrowFunctionExpression) {
           const calledBinding = findCallToBinding(expr.body);
           if (calledBinding) {
-            flaggedBindings.add(calledBinding);
+            addFlaggedUsage(calledBinding, {
+              reason: 'directlyInvoked',
+              line: node.value.loc.start.line,
+            });
             return;
           }
         }
@@ -116,7 +144,11 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
             tagName.name[0] === tagName.name[0]?.toLowerCase()
           ) {
             // Case 2: Direct reference on an intrinsic element
-            flaggedBindings.add(expr.name);
+            addFlaggedUsage(expr.name, {
+              reason: 'intrinsicElement',
+              element: tagName.name,
+              line: node.value.loc.start.line,
+            });
           } else {
             // Passed directly to a custom component — memoization is justified
             justifiedBindings.add(expr.name);
@@ -125,7 +157,7 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
       },
 
       'Program:exit'() {
-        for (const name of flaggedBindings) {
+        for (const [name, usages] of flaggedUsages) {
           if (justifiedBindings.has(name)) {
             continue;
           }
@@ -134,7 +166,7 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
             context.report({
               node: callNode,
               messageId: 'unnecessaryUseCallback',
-              data: {name},
+              data: {name, usages: formatUsages(usages)},
             });
           }
         }

From 27924844a1d9aa82525b9d321714063a42550e4a Mon Sep 17 00:00:00 2001
From: TkDodo <dominik.dorfmeister@sentry.io>
Date: Fri, 10 Apr 2026 17:35:08 +0200
Subject: [PATCH 04/14] add suggestions

---
 .../no-unnecessary-use-callback.spec.ts       | 70 +++++++++++++++++++
 .../no-unnecessary-use-callback.ts            | 19 ++++-
 2 files changed, 87 insertions(+), 2 deletions(-)

diff --git a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
index e8909068d10ab4..c740a211fae520 100644
--- a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
+++ b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
@@ -110,6 +110,13 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
         {
           messageId: 'unnecessaryUseCallback',
           data: {name: 'fn', usages: 'directly invoked in line 2'},
+          suggestions: [
+            {
+              messageId: 'removeUseCallback',
+              output: `const fn = () => { console.log('click'); };
+<button onClick={() => fn()} />`,
+            },
+          ],
         },
       ],
     },
@@ -121,6 +128,13 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
         {
           messageId: 'unnecessaryUseCallback',
           data: {name: 'fn', usages: 'directly invoked in line 2'},
+          suggestions: [
+            {
+              messageId: 'removeUseCallback',
+              output: `const fn = () => { console.log('click'); };
+<MyComponent onClick={() => fn()} />`,
+            },
+          ],
         },
       ],
     },
@@ -132,6 +146,13 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
         {
           messageId: 'unnecessaryUseCallback',
           data: {name: 'fn', usages: 'directly invoked in line 2'},
+          suggestions: [
+            {
+              messageId: 'removeUseCallback',
+              output: `const fn = (e) => { console.log(e); };
+<button onClick={(e) => fn(e)} />`,
+            },
+          ],
         },
       ],
     },
@@ -146,6 +167,13 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
             name: 'fn',
             usages: 'passed to intrinsic element <button> in line 2',
           },
+          suggestions: [
+            {
+              messageId: 'removeUseCallback',
+              output: `const fn = (e) => { console.log('click'); };
+<button onClick={fn} />`,
+            },
+          ],
         },
       ],
     },
@@ -160,6 +188,13 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
             name: 'fn',
             usages: 'passed to intrinsic element <div> in line 2',
           },
+          suggestions: [
+            {
+              messageId: 'removeUseCallback',
+              output: `const fn = () => {};
+<div onMouseEnter={fn} />`,
+            },
+          ],
         },
       ],
     },
@@ -174,6 +209,13 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
             name: 'fn',
             usages: 'passed to intrinsic element <input> in line 2',
           },
+          suggestions: [
+            {
+              messageId: 'removeUseCallback',
+              output: `const fn = () => {};
+<input onChange={fn} />`,
+            },
+          ],
         },
       ],
     },
@@ -188,6 +230,13 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
             name: 'fn',
             usages: 'passed to intrinsic element <a> in line 2',
           },
+          suggestions: [
+            {
+              messageId: 'removeUseCallback',
+              output: `const fn = () => {};
+<a onClick={fn} />`,
+            },
+          ],
         },
       ],
     },
@@ -199,6 +248,13 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
         {
           messageId: 'unnecessaryUseCallback',
           data: {name: 'handler', usages: 'directly invoked in line 2'},
+          suggestions: [
+            {
+              messageId: 'removeUseCallback',
+              output: `const handler = (a, b) => {};
+<button onClick={(a, b) => handler(a, b)} />`,
+            },
+          ],
         },
       ],
     },
@@ -210,6 +266,13 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
         {
           messageId: 'unnecessaryUseCallback',
           data: {name: 'fn', usages: 'directly invoked in line 2'},
+          suggestions: [
+            {
+              messageId: 'removeUseCallback',
+              output: `const fn = () => {};
+<button onClick={() => { fn(); doSomethingElse(); }} />`,
+            },
+          ],
         },
       ],
     },
@@ -225,6 +288,13 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
             usages:
               'directly invoked in line 2 and passed to intrinsic element <div> in line 2',
           },
+          suggestions: [
+            {
+              messageId: 'removeUseCallback',
+              output: `const fn = () => {};
+<><button onClick={() => fn()} /><div onMouseEnter={fn} /></>`,
+            },
+          ],
         },
       ],
     },
diff --git a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
index ccf2bca2442ebc..2ee61a57ab43f9 100644
--- a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
+++ b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
@@ -17,17 +17,22 @@ function formatUsages(usages: UsageInfo[]): string {
     .join(' and ');
 }
 
-export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
+export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs<
+  readonly unknown[],
+  'unnecessaryUseCallback' | 'removeUseCallback'
+>({
   meta: {
     type: 'suggestion',
     docs: {
       description:
         'Disallow useCallback where it provides no benefit: when the result is directly invoked (defeating memoization) or passed to intrinsic elements (which are not memoized).',
     },
+    hasSuggestions: true,
     schema: [],
     messages: {
       unnecessaryUseCallback:
         'Unnecessary useCallback. `{{name}}` is only used in contexts where memoization provides no benefit. It is {{usages}}.',
+      removeUseCallback: 'Remove useCallback wrapper.',
     },
   },
   create(context) {
@@ -162,11 +167,21 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
             continue;
           }
           const callNode = useCallbackBindings.get(name);
-          if (callNode) {
+          if (callNode && callNode.arguments.length > 0) {
+            const firstArg = callNode.arguments[0];
+            const callbackText = context.sourceCode.getText(firstArg);
             context.report({
               node: callNode,
               messageId: 'unnecessaryUseCallback',
               data: {name, usages: formatUsages(usages)},
+              suggest: [
+                {
+                  messageId: 'removeUseCallback',
+                  fix(fixer) {
+                    return fixer.replaceText(callNode, callbackText);
+                  },
+                },
+              ],
             });
           }
         }

From 4939c28f047ef1459b209701560d89f02ea3ddbe Mon Sep 17 00:00:00 2001
From: TkDodo <dominik.dorfmeister@sentry.io>
Date: Fri, 10 Apr 2026 17:40:01 +0200
Subject: [PATCH 05/14] fix any other expression usage

---
 .../no-unnecessary-use-callback.spec.ts       | 16 +++
 .../no-unnecessary-use-callback.ts            | 99 ++++++++++++-------
 2 files changed, 77 insertions(+), 38 deletions(-)

diff --git a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
index c740a211fae520..4a6e44b2800c2d 100644
--- a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
+++ b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
@@ -99,6 +99,22 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
         <input ref={fn} />
       `,
     },
+    {
+      name: 'useCallback used in useEffect dependency array alongside intrinsic element',
+      code: `
+        const fn = useCallback(() => {}, []);
+        useEffect(() => { fn() }, [fn]);
+        <button onClick={fn} />
+      `,
+    },
+    {
+      name: 'useCallback used in any other expression alongside direct invocation',
+      code: `
+        const fn = useCallback(() => {}, []);
+        console.log(fn);
+        <button onClick={() => fn()} />
+      `,
+    },
   ],
 
   invalid: [
diff --git a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
index 2ee61a57ab43f9..35f8df258b3d7e 100644
--- a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
+++ b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
@@ -36,21 +36,24 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs<
     },
   },
   create(context) {
-    // Maps binding name to the useCallback() CallExpression node
-    const useCallbackBindings = new Map<string, TSESTree.CallExpression>();
-    // Bindings that have at least one usage where memoization is justified
-    // (e.g. passed directly to a custom component)
-    const justifiedBindings = new Set<string>();
+    // Maps binding name to the useCallback() CallExpression node and its declaring scope
+    const useCallbackBindings = new Map<
+      string,
+      {declarator: TSESTree.VariableDeclarator; node: TSESTree.CallExpression}
+    >();
     // Collected flagged usages per binding
     const flaggedUsages = new Map<string, UsageInfo[]>();
+    // Number of references we've accounted for (flagged) per binding
+    const flaggedRefCount = new Map<string, number>();
 
-    function addFlaggedUsage(name: string, usage: UsageInfo) {
+    function addFlaggedUsage(name: string, usage: UsageInfo, refCount: number) {
       let usages = flaggedUsages.get(name);
       if (!usages) {
         usages = [];
         flaggedUsages.set(name, usages);
       }
       usages.push(usage);
+      flaggedRefCount.set(name, (flaggedRefCount.get(name) ?? 0) + refCount);
     }
 
     /**
@@ -102,7 +105,7 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs<
           node.init.callee.type === AST_NODE_TYPES.Identifier &&
           node.init.callee.name === 'useCallback'
         ) {
-          useCallbackBindings.set(node.id.name, node.init);
+          useCallbackBindings.set(node.id.name, {node: node.init, declarator: node});
         }
       },
 
@@ -116,13 +119,17 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs<
         // Case 1: Arrow function that calls a useCallback binding in its body
         // e.g. onClick={() => fn()}, onClick={(e) => fn(e)},
         //      onClick={() => { fn(); doSomethingElse(); }}
+        // Case 1: Arrow function that calls a useCallback binding in its body
+        // The arrow wrapper creates a new ref each render, defeating memoization.
+        // The binding is referenced inside the arrow body — count as 1 reference.
         if (expr.type === AST_NODE_TYPES.ArrowFunctionExpression) {
           const calledBinding = findCallToBinding(expr.body);
           if (calledBinding) {
-            addFlaggedUsage(calledBinding, {
-              reason: 'directlyInvoked',
-              line: node.value.loc.start.line,
-            });
+            addFlaggedUsage(
+              calledBinding,
+              {reason: 'directlyInvoked', line: node.value.loc.start.line},
+              1
+            );
             return;
           }
         }
@@ -134,6 +141,7 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs<
           return;
         }
 
+        // Case 2: Direct reference on an intrinsic element — counts as 1 reference.
         if (
           expr.type === AST_NODE_TYPES.Identifier &&
           useCallbackBindings.has(expr.name)
@@ -148,42 +156,57 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs<
             tagName.type === AST_NODE_TYPES.JSXIdentifier &&
             tagName.name[0] === tagName.name[0]?.toLowerCase()
           ) {
-            // Case 2: Direct reference on an intrinsic element
-            addFlaggedUsage(expr.name, {
-              reason: 'intrinsicElement',
-              element: tagName.name,
-              line: node.value.loc.start.line,
-            });
-          } else {
-            // Passed directly to a custom component — memoization is justified
-            justifiedBindings.add(expr.name);
+            addFlaggedUsage(
+              expr.name,
+              {
+                reason: 'intrinsicElement',
+                element: tagName.name,
+                line: node.value.loc.start.line,
+              },
+              1
+            );
           }
         }
       },
 
       'Program:exit'() {
         for (const [name, usages] of flaggedUsages) {
-          if (justifiedBindings.has(name)) {
+          const binding = useCallbackBindings.get(name);
+          if (!binding || binding.node.arguments.length === 0) {
             continue;
           }
-          const callNode = useCallbackBindings.get(name);
-          if (callNode && callNode.arguments.length > 0) {
-            const firstArg = callNode.arguments[0];
-            const callbackText = context.sourceCode.getText(firstArg);
-            context.report({
-              node: callNode,
-              messageId: 'unnecessaryUseCallback',
-              data: {name, usages: formatUsages(usages)},
-              suggest: [
-                {
-                  messageId: 'removeUseCallback',
-                  fix(fixer) {
-                    return fixer.replaceText(callNode, callbackText);
-                  },
-                },
-              ],
-            });
+
+          // Count total references to this binding via scope analysis.
+          // If there are references beyond the ones we flagged, the
+          // useCallback may be justified (dep arrays, other hooks, etc.)
+          const scope = context.sourceCode.getScope(binding.declarator);
+          const variable = scope.variables.find(v => v.name === name);
+          // references includes the declaration itself, so subtract 1
+          const totalRefs = variable
+            ? variable.references.filter(r => r.isRead()).length
+            : 0;
+          const flagged = flaggedRefCount.get(name) ?? 0;
+
+          if (totalRefs > flagged) {
+            continue;
           }
+
+          const callNode = binding.node;
+          const firstArg = callNode.arguments[0];
+          const callbackText = context.sourceCode.getText(firstArg);
+          context.report({
+            node: callNode,
+            messageId: 'unnecessaryUseCallback',
+            data: {name, usages: formatUsages(usages)},
+            suggest: [
+              {
+                messageId: 'removeUseCallback',
+                fix(fixer) {
+                  return fixer.replaceText(callNode, callbackText);
+                },
+              },
+            ],
+          });
         }
       },
     };

From 48d7e314ca2b175dfd6d0dce4b2f342e23add5bb Mon Sep 17 00:00:00 2001
From: TkDodo <dominik.dorfmeister@sentry.io>
Date: Fri, 10 Apr 2026 17:45:33 +0200
Subject: [PATCH 06/14] indentation

---
 .../no-unnecessary-use-callback.spec.ts       | 140 +++++++++++-------
 1 file changed, 90 insertions(+), 50 deletions(-)

diff --git a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
index 4a6e44b2800c2d..0c17b6ad42c528 100644
--- a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
+++ b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
@@ -120,17 +120,21 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
   invalid: [
     {
       name: 'arrow wrap on intrinsic element',
-      code: `const fn = useCallback(() => { console.log('click'); }, []);
-<button onClick={() => fn()} />`,
+      code: `
+        const fn = useCallback(() => { console.log('click'); }, []);
+        <button onClick={() => fn()} />
+      `,
       errors: [
         {
           messageId: 'unnecessaryUseCallback',
-          data: {name: 'fn', usages: 'directly invoked in line 2'},
+          data: {name: 'fn', usages: 'directly invoked in line 3'},
           suggestions: [
             {
               messageId: 'removeUseCallback',
-              output: `const fn = () => { console.log('click'); };
-<button onClick={() => fn()} />`,
+              output: `
+        const fn = () => { console.log('click'); };
+        <button onClick={() => fn()} />
+      `,
             },
           ],
         },
@@ -138,17 +142,21 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
     },
     {
       name: 'arrow wrap on custom component',
-      code: `const fn = useCallback(() => { console.log('click'); }, []);
-<MyComponent onClick={() => fn()} />`,
+      code: `
+        const fn = useCallback(() => { console.log('click'); }, []);
+        <MyComponent onClick={() => fn()} />
+      `,
       errors: [
         {
           messageId: 'unnecessaryUseCallback',
-          data: {name: 'fn', usages: 'directly invoked in line 2'},
+          data: {name: 'fn', usages: 'directly invoked in line 3'},
           suggestions: [
             {
               messageId: 'removeUseCallback',
-              output: `const fn = () => { console.log('click'); };
-<MyComponent onClick={() => fn()} />`,
+              output: `
+        const fn = () => { console.log('click'); };
+        <MyComponent onClick={() => fn()} />
+      `,
             },
           ],
         },
@@ -156,17 +164,21 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
     },
     {
       name: 'arrow wrap with argument forwarding',
-      code: `const fn = useCallback((e) => { console.log(e); }, []);
-<button onClick={(e) => fn(e)} />`,
+      code: `
+        const fn = useCallback((e) => { console.log(e); }, []);
+        <button onClick={(e) => fn(e)} />
+      `,
       errors: [
         {
           messageId: 'unnecessaryUseCallback',
-          data: {name: 'fn', usages: 'directly invoked in line 2'},
+          data: {name: 'fn', usages: 'directly invoked in line 3'},
           suggestions: [
             {
               messageId: 'removeUseCallback',
-              output: `const fn = (e) => { console.log(e); };
-<button onClick={(e) => fn(e)} />`,
+              output: `
+        const fn = (e) => { console.log(e); };
+        <button onClick={(e) => fn(e)} />
+      `,
             },
           ],
         },
@@ -174,20 +186,24 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
     },
     {
       name: 'direct reference on <button>',
-      code: `const fn = useCallback((e) => { console.log('click'); }, []);
-<button onClick={fn} />`,
+      code: `
+        const fn = useCallback((e) => { console.log('click'); }, []);
+        <button onClick={fn} />
+      `,
       errors: [
         {
           messageId: 'unnecessaryUseCallback',
           data: {
             name: 'fn',
-            usages: 'passed to intrinsic element <button> in line 2',
+            usages: 'passed to intrinsic element <button> in line 3',
           },
           suggestions: [
             {
               messageId: 'removeUseCallback',
-              output: `const fn = (e) => { console.log('click'); };
-<button onClick={fn} />`,
+              output: `
+        const fn = (e) => { console.log('click'); };
+        <button onClick={fn} />
+      `,
             },
           ],
         },
@@ -195,20 +211,24 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
     },
     {
       name: 'direct reference on <div>',
-      code: `const fn = useCallback(() => {}, []);
-<div onMouseEnter={fn} />`,
+      code: `
+        const fn = useCallback(() => {}, []);
+        <div onMouseEnter={fn} />
+      `,
       errors: [
         {
           messageId: 'unnecessaryUseCallback',
           data: {
             name: 'fn',
-            usages: 'passed to intrinsic element <div> in line 2',
+            usages: 'passed to intrinsic element <div> in line 3',
           },
           suggestions: [
             {
               messageId: 'removeUseCallback',
-              output: `const fn = () => {};
-<div onMouseEnter={fn} />`,
+              output: `
+        const fn = () => {};
+        <div onMouseEnter={fn} />
+      `,
             },
           ],
         },
@@ -216,20 +236,24 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
     },
     {
       name: 'direct reference on <input>',
-      code: `const fn = useCallback(() => {}, []);
-<input onChange={fn} />`,
+      code: `
+        const fn = useCallback(() => {}, []);
+        <input onChange={fn} />
+      `,
       errors: [
         {
           messageId: 'unnecessaryUseCallback',
           data: {
             name: 'fn',
-            usages: 'passed to intrinsic element <input> in line 2',
+            usages: 'passed to intrinsic element <input> in line 3',
           },
           suggestions: [
             {
               messageId: 'removeUseCallback',
-              output: `const fn = () => {};
-<input onChange={fn} />`,
+              output: `
+        const fn = () => {};
+        <input onChange={fn} />
+      `,
             },
           ],
         },
@@ -237,20 +261,24 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
     },
     {
       name: 'direct reference on <a>',
-      code: `const fn = useCallback(() => {}, []);
-<a onClick={fn} />`,
+      code: `
+        const fn = useCallback(() => {}, []);
+        <a onClick={fn} />
+      `,
       errors: [
         {
           messageId: 'unnecessaryUseCallback',
           data: {
             name: 'fn',
-            usages: 'passed to intrinsic element <a> in line 2',
+            usages: 'passed to intrinsic element <a> in line 3',
           },
           suggestions: [
             {
               messageId: 'removeUseCallback',
-              output: `const fn = () => {};
-<a onClick={fn} />`,
+              output: `
+        const fn = () => {};
+        <a onClick={fn} />
+      `,
             },
           ],
         },
@@ -258,17 +286,21 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
     },
     {
       name: 'arrow wrap with multiple arguments',
-      code: `const handler = useCallback((a, b) => {}, []);
-<button onClick={(a, b) => handler(a, b)} />`,
+      code: `
+        const handler = useCallback((a, b) => {}, []);
+        <button onClick={(a, b) => handler(a, b)} />
+      `,
       errors: [
         {
           messageId: 'unnecessaryUseCallback',
-          data: {name: 'handler', usages: 'directly invoked in line 2'},
+          data: {name: 'handler', usages: 'directly invoked in line 3'},
           suggestions: [
             {
               messageId: 'removeUseCallback',
-              output: `const handler = (a, b) => {};
-<button onClick={(a, b) => handler(a, b)} />`,
+              output: `
+        const handler = (a, b) => {};
+        <button onClick={(a, b) => handler(a, b)} />
+      `,
             },
           ],
         },
@@ -276,17 +308,21 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
     },
     {
       name: 'useCallback called inside block-body arrow with additional logic',
-      code: `const fn = useCallback(() => {}, []);
-<button onClick={() => { fn(); doSomethingElse(); }} />`,
+      code: `
+        const fn = useCallback(() => {}, []);
+        <button onClick={() => { fn(); doSomethingElse(); }} />
+      `,
       errors: [
         {
           messageId: 'unnecessaryUseCallback',
-          data: {name: 'fn', usages: 'directly invoked in line 2'},
+          data: {name: 'fn', usages: 'directly invoked in line 3'},
           suggestions: [
             {
               messageId: 'removeUseCallback',
-              output: `const fn = () => {};
-<button onClick={() => { fn(); doSomethingElse(); }} />`,
+              output: `
+        const fn = () => {};
+        <button onClick={() => { fn(); doSomethingElse(); }} />
+      `,
             },
           ],
         },
@@ -294,21 +330,25 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
     },
     {
       name: 'multiple flagged usages reported together',
-      code: `const fn = useCallback(() => {}, []);
-<><button onClick={() => fn()} /><div onMouseEnter={fn} /></>`,
+      code: `
+        const fn = useCallback(() => {}, []);
+        <><button onClick={() => fn()} /><div onMouseEnter={fn} /></>
+      `,
       errors: [
         {
           messageId: 'unnecessaryUseCallback',
           data: {
             name: 'fn',
             usages:
-              'directly invoked in line 2 and passed to intrinsic element <div> in line 2',
+              'directly invoked in line 3 and passed to intrinsic element <div> in line 3',
           },
           suggestions: [
             {
               messageId: 'removeUseCallback',
-              output: `const fn = () => {};
-<><button onClick={() => fn()} /><div onMouseEnter={fn} /></>`,
+              output: `
+        const fn = () => {};
+        <><button onClick={() => fn()} /><div onMouseEnter={fn} /></>
+      `,
             },
           ],
         },

From 285fc62df2a1983ee6dfb1b628c269fe1b029b48 Mon Sep 17 00:00:00 2001
From: TkDodo <dominik.dorfmeister@sentry.io>
Date: Fri, 10 Apr 2026 17:51:36 +0200
Subject: [PATCH 07/14] treat scraps components like intrinsic elements

---
 .../no-unnecessary-use-callback.spec.ts       | 63 +++++++++++++++++++
 .../no-unnecessary-use-callback.ts            | 43 ++++++++++++-
 2 files changed, 104 insertions(+), 2 deletions(-)

diff --git a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
index 0c17b6ad42c528..b5d67c88513c0f 100644
--- a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
+++ b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
@@ -115,6 +115,15 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
         <button onClick={() => fn()} />
       `,
     },
+    {
+      name: 'useCallback passed to scraps component justified by other usage',
+      code: `
+        import {Button} from '@sentry/scraps/button';
+        const fn = useCallback(() => {}, []);
+        console.log(fn);
+        <Button onClick={fn} />
+      `,
+    },
   ],
 
   invalid: [
@@ -354,5 +363,59 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
         },
       ],
     },
+    {
+      name: 'useCallback passed to @sentry/scraps component',
+      code: `
+        import {Button} from '@sentry/scraps/button';
+        const fn = useCallback(() => {}, []);
+        <Button onClick={fn} />
+      `,
+      errors: [
+        {
+          messageId: 'unnecessaryUseCallback',
+          data: {
+            name: 'fn',
+            usages: 'passed to unmemoized component <Button> in line 4',
+          },
+          suggestions: [
+            {
+              messageId: 'removeUseCallback',
+              output: `
+        import {Button} from '@sentry/scraps/button';
+        const fn = () => {};
+        <Button onClick={fn} />
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      name: 'useCallback passed to @sentry/scraps namespaced component',
+      code: `
+        import {Flex} from '@sentry/scraps/layout';
+        const fn = useCallback(() => {}, []);
+        <Flex onClick={fn} />
+      `,
+      errors: [
+        {
+          messageId: 'unnecessaryUseCallback',
+          data: {
+            name: 'fn',
+            usages: 'passed to unmemoized component <Flex> in line 4',
+          },
+          suggestions: [
+            {
+              messageId: 'removeUseCallback',
+              output: `
+        import {Flex} from '@sentry/scraps/layout';
+        const fn = () => {};
+        <Flex onClick={fn} />
+      `,
+            },
+          ],
+        },
+      ],
+    },
   ],
 });
diff --git a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
index 35f8df258b3d7e..373446d5bba993 100644
--- a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
+++ b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
@@ -2,7 +2,7 @@ import {AST_NODE_TYPES, ESLintUtils, type TSESTree} from '@typescript-eslint/uti
 
 interface UsageInfo {
   line: number;
-  reason: 'directlyInvoked' | 'intrinsicElement';
+  reason: 'directlyInvoked' | 'intrinsicElement' | 'unmemoizedComponent';
   element?: string;
 }
 
@@ -12,6 +12,9 @@ function formatUsages(usages: UsageInfo[]): string {
       if (u.reason === 'directlyInvoked') {
         return `directly invoked in line ${u.line}`;
       }
+      if (u.reason === 'unmemoizedComponent') {
+        return `passed to unmemoized component <${u.element}> in line ${u.line}`;
+      }
       return `passed to intrinsic element <${u.element}> in line ${u.line}`;
     })
     .join(' and ');
@@ -45,6 +48,8 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs<
     const flaggedUsages = new Map<string, UsageInfo[]>();
     // Number of references we've accounted for (flagged) per binding
     const flaggedRefCount = new Map<string, number>();
+    // Local names imported from @sentry/scraps (these components are never memoized)
+    const scrapsImports = new Set<string>();
 
     function addFlaggedUsage(name: string, usage: UsageInfo, refCount: number) {
       let usages = flaggedUsages.get(name);
@@ -95,7 +100,29 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs<
       return null;
     }
 
+    function getJSXElementName(nameNode: TSESTree.JSXTagNameExpression): string | null {
+      if (nameNode.type === AST_NODE_TYPES.JSXIdentifier) {
+        return nameNode.name;
+      }
+      if (
+        nameNode.type === AST_NODE_TYPES.JSXMemberExpression &&
+        nameNode.object.type === AST_NODE_TYPES.JSXIdentifier
+      ) {
+        return nameNode.object.name;
+      }
+      return null;
+    }
+
     return {
+      ImportDeclaration(node) {
+        const source = node.source.value;
+        if (typeof source === 'string' && source.startsWith('@sentry/scraps')) {
+          for (const spec of node.specifiers) {
+            scrapsImports.add(spec.local.name);
+          }
+        }
+      },
+
       VariableDeclarator(node) {
         if (node.id.type !== AST_NODE_TYPES.Identifier) {
           return;
@@ -141,7 +168,8 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs<
           return;
         }
 
-        // Case 2: Direct reference on an intrinsic element — counts as 1 reference.
+        // Case 2: Direct reference on an unmemoized element — counts as 1 reference.
+        // This includes intrinsic elements and components from @sentry/scraps.
         if (
           expr.type === AST_NODE_TYPES.Identifier &&
           useCallbackBindings.has(expr.name)
@@ -151,6 +179,7 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs<
             return;
           }
           const tagName = openingElement.name;
+          const elementName = getJSXElementName(tagName);
 
           if (
             tagName.type === AST_NODE_TYPES.JSXIdentifier &&
@@ -165,6 +194,16 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs<
               },
               1
             );
+          } else if (elementName && scrapsImports.has(elementName)) {
+            addFlaggedUsage(
+              expr.name,
+              {
+                reason: 'unmemoizedComponent',
+                element: elementName,
+                line: node.value.loc.start.line,
+              },
+              1
+            );
           }
         }
       },

From d0566ab1a9becc44f8d34220e3801501303181de Mon Sep 17 00:00:00 2001
From: TkDodo <dominik.dorfmeister@sentry.io>
Date: Fri, 10 Apr 2026 18:10:59 +0200
Subject: [PATCH 08/14] exclude some components

---
 .../no-unnecessary-use-callback.spec.ts          | 16 ++++++++++++++++
 .../no-unnecessary-use-callback.ts               |  7 ++++++-
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
index b5d67c88513c0f..ee0c3f3087ee4b 100644
--- a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
+++ b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
@@ -124,6 +124,22 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
         <Button onClick={fn} />
       `,
     },
+    {
+      name: 'useCallback passed to excluded scraps component CompactSelect',
+      code: `
+        import {CompactSelect} from '@sentry/scraps/compactSelect';
+        const fn = useCallback(() => {}, []);
+        <CompactSelect onChange={fn} />
+      `,
+    },
+    {
+      name: 'useCallback passed to excluded scraps component CodeBlock',
+      code: `
+        import {CodeBlock} from '@sentry/scraps/codeBlock';
+        const fn = useCallback(() => {}, []);
+        <CodeBlock onCopy={fn} />
+      `,
+    },
   ],
 
   invalid: [
diff --git a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
index 373446d5bba993..48c309420dab52 100644
--- a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
+++ b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
@@ -113,12 +113,17 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs<
       return null;
     }
 
+    // Scraps components that use memoized callbacks internally
+    const scrapsExclusions = new Set(['CompactSelect', 'CodeBlock']);
+
     return {
       ImportDeclaration(node) {
         const source = node.source.value;
         if (typeof source === 'string' && source.startsWith('@sentry/scraps')) {
           for (const spec of node.specifiers) {
-            scrapsImports.add(spec.local.name);
+            if (!scrapsExclusions.has(spec.local.name)) {
+              scrapsImports.add(spec.local.name);
+            }
           }
         }
       },

From 5ada25ed171cf306beaf6d6185b8e3a8ffbdebd4 Mon Sep 17 00:00:00 2001
From: TkDodo <dominik.dorfmeister@sentry.io>
Date: Fri, 10 Apr 2026 19:19:14 +0200
Subject: [PATCH 09/14] ref: remove unnecessary useCallbacks

---
 .../app/components/assistant/guideAnchor.tsx  |  15 +-
 .../components/avatarChooser/useUploader.tsx  |  45 ++--
 static/app/components/clippedBox.tsx          |  82 +++---
 .../components/core/input/numberDragInput.tsx |  58 ++--
 static/app/components/core/inspector.tsx      |  33 ++-
 .../events/autofix/autofixStepFeedback.tsx    |  37 ++-
 .../autofix/codingAgentIntegrationCta.tsx     |  20 +-
 .../autofix/githubCopilotIntegrationCta.tsx   |   6 +-
 .../breadcrumbs/breadcrumbsDataSection.tsx    |  75 +++---
 .../events/eventTagsAndScreenshot/tags.tsx    |   6 +-
 .../featureFlags/eventFeatureFlagSection.tsx  |  63 +++--
 .../highlights/highlightsDataSection.tsx      |   8 +-
 .../events/metrics/metricsSection.tsx         |  35 ++-
 .../events/suspectCommitFeedback.tsx          |  25 +-
 .../events/traceEventDataSection.tsx          | 247 +++++++++---------
 .../externalIssues/externalIssueForm.tsx      |  11 +-
 .../feedbackItem/feedbackItemUsername.tsx     |   6 +-
 static/app/components/forms/form.tsx          |  42 +--
 .../groupPreviewHovercard.tsx                 |   6 +-
 .../modals/explore/saveQueryModal.tsx         |  16 +-
 .../inviteMissingMembersModal/index.tsx       |  55 ++--
 .../modals/projectCreationModal.tsx           |  10 +-
 .../onboarding/productSelection.tsx           |  57 ++--
 .../components/onboardingWizard/content.tsx   |   4 +-
 .../environment/environmentPageFilter.tsx     |   4 +-
 .../profiling/continuousProfileHeader.tsx     |   6 +-
 .../flamegraphDrawer/flamegraphDrawer.tsx     |  21 +-
 .../flamegraphDrawer/flamegraphTreeTable.tsx  |  19 +-
 .../flamegraphDrawer/profileDetails.tsx       |  10 +-
 .../differentialFlamegraphNegationSwitch.tsx  |  10 +-
 .../differentialFlamegraphSettingsButton.tsx  |   4 +-
 .../differentialFlamegraphToolbar.tsx         |   5 +-
 .../flamegraphOptionsMenu.tsx                 |   4 +-
 .../components/profiling/profileHeader.tsx    |   6 +-
 .../projects/missingProjectMembership.tsx     |   6 +-
 .../breadcrumbs/breadcrumbIssueLink.tsx       |   6 +-
 .../replays/breadcrumbs/errorTitle.tsx        |   6 +-
 .../replays/replayFullscreenButton.tsx        |   5 +-
 .../replays/table/deleteReplays.tsx           |  10 +-
 .../replays/timeAndScrubberGrid.tsx           |  10 +-
 .../selectionKeyHandler.tsx                   | 244 +++++++++--------
 .../components/stackTrace/exceptionGroup.tsx  |   4 +-
 .../components/timeRangeSelector/index.tsx    |  51 ++--
 .../components/webAuthn/webAuthnEnroll.tsx    |  37 ++-
 .../components/debugNotificationsHeader.tsx   |   5 +-
 static/app/stories/theme.tsx                  |   6 +-
 .../performance/contexts/onDemandControl.tsx  |   4 +-
 static/app/views/admin/adminRelays.tsx        |  21 +-
 .../anomalyDetectionFeedbackBanner.tsx        |  75 +++---
 .../views/alerts/rules/metric/eapField.tsx    |  23 +-
 .../alerts/rules/metric/eapMetricsField.tsx   |  39 ++-
 .../uptime/assertionSuggestionsButton.tsx     |   4 +-
 .../rules/uptime/testUptimeMonitorButton.tsx  |   8 +-
 .../components/automationBuilder.tsx          |   8 +-
 .../automationListTable/actions.tsx           |  54 ++--
 .../components/editAutomationActions.tsx      |   9 +-
 static/app/views/automations/detail.tsx       |   6 +-
 .../views/dashboards/createFromSeerPrompt.tsx |   6 +-
 static/app/views/dashboards/dashboard.tsx     |  41 ++-
 .../views/dashboards/dashboardChatPanel.tsx   |  19 +-
 .../widgetBuilder/components/saveButton.tsx   |   8 +-
 .../components/widgetTemplatesList.tsx        |  23 +-
 .../components/details/common/actions.tsx     |  10 +-
 .../components/detectorListTable/actions.tsx  |  54 ++--
 .../forms/metric/metricsVisualize.tsx         |  29 +-
 .../schemaHints/schemaHintsDrawer.tsx         |  85 +++---
 .../schemaHints/schemaHintsList.tsx           | 202 +++++++-------
 static/app/views/explore/logs/logsTab.tsx     |  27 +-
 static/app/views/explore/logs/logsToolbar.tsx |  21 +-
 .../explore/logs/tables/logsTableRow.tsx      |  16 +-
 .../metrics/metricToolbar/metricSelector.tsx  |   4 +-
 .../tables/aggregateColumnEditorModal.tsx     |  29 +-
 static/app/views/explore/tables/index.tsx     |  10 +-
 .../views/explore/toolbar/toolbarSortBy.tsx   |  48 ++--
 .../explore/toolbar/toolbarVisualize.tsx      |  42 ++-
 .../crons/components/timezoneOverride.tsx     |  13 +-
 .../pages/agents/components/drawer.tsx        |   4 +-
 .../pages/agents/components/tracesTable.tsx   |   4 +-
 .../components/conversationSummary.tsx        |   6 +-
 .../components/conversationView.tsx           |  23 +-
 .../views/issueDetails/actions/shareModal.tsx |  64 ++---
 .../similarStackTrace/item.tsx                |  25 +-
 .../issueDetails/streamline/eventTitle.tsx    |   6 +-
 .../streamline/instrumentationFixSection.tsx  |   4 +-
 .../streamline/sidebar/activitySection.tsx    |  41 ++-
 .../streamline/sidebar/autofixSection.tsx     |   8 +-
 .../streamline/sidebar/seerNotices.tsx        |  11 +-
 .../supergroups/supergroupFeedback.tsx        |  23 +-
 .../app/views/navigation/mobileNavigation.tsx |   7 +-
 .../components/welcomeSkipButton.tsx          |   6 +-
 static/app/views/onboarding/onboarding.tsx    |  39 ++-
 .../views/onboarding/scmPlatformFeatures.tsx  | 181 ++++++-------
 .../landing/metricsDataSwitcherAlert.tsx      |  10 +-
 .../traceDrawer/tabs/traceAiSpans.tsx         |   4 +-
 .../traceDrawer/tabs/traceProfiles.tsx        |  19 +-
 .../newTraceDetails/traceRow/traceBar.tsx     |  11 +-
 .../traceSearch/traceSearchInput.tsx          | 104 ++++----
 .../transactionSummary/pageLayout.tsx         |  31 +--
 .../transactionProfiles/content.tsx           |   4 +-
 .../main/insights/appSizeInsights.tsx         |   4 +-
 .../header/snapshotHeaderActions.tsx          |   4 +-
 static/app/views/profiling/content.tsx        |  47 ++--
 .../profiling/landingAggregateFlamegraph.tsx  |   4 +-
 static/app/views/projectInstall/platform.tsx  |  41 ++-
 .../pullRequest/details/main/prFilesList.tsx  |   6 +-
 .../views/releases/list/releaseHealthCTA.tsx  |   5 +-
 .../app/views/releases/list/releasesPromo.tsx |  17 +-
 static/app/views/relocation/relocation.tsx    |  13 +-
 .../views/replays/detail/ai/chapterList.tsx   |  13 +-
 .../replays/list/saveReplayQueryButton.tsx    |   6 +-
 .../views/seerExplorer/blockComponents.tsx    |  44 ++--
 .../modals/dataScrubFormModal.tsx             |  29 +-
 .../settingsBreadcrumb/breadcrumbDropdown.tsx |   4 +-
 .../changeTracking/newProviderForm.tsx        |   5 +-
 .../organizationAuthTokens/newAuthToken.tsx   |  11 +-
 .../sentryApplicationDashboard/requestLog.tsx |  21 +-
 .../SplitInstallationIdModal.tsx              |   4 +-
 .../organizationRelay/relayWrapper.tsx        |  84 +++---
 .../project/preprod/statusCheckRuleForm.tsx   |   6 +-
 .../project/preprod/statusCheckRules.tsx      |  25 +-
 .../projectFilters/projectFiltersSettings.tsx |  33 ++-
 .../projectKeys/details/keySettings.tsx       |   6 +-
 .../projectKeys/details/loaderSettings.tsx    | 142 +++++-----
 .../projectSeer/autofixRepositories.tsx       |  46 ++--
 .../overview/codeReviewOverviewSection.tsx    | 124 ++++-----
 .../setupWizard/wizardProjectSelection.tsx    |  85 +++---
 static/gsAdmin/views/broadcasts.tsx           |   5 +-
 .../components/productUnavailableCTA.tsx      |  10 +-
 .../profiling/profilingUpgradeModal.tsx       |  10 +-
 .../gsApp/components/replayOnboardingCTA.tsx  |  14 +-
 .../upgradeNowModal/actionButtons.tsx         |  24 +-
 .../upgradeNowModal/modalSamePrice.tsx        |   5 +-
 .../views/amCheckout/steps/setSpendLimit.tsx  |  39 ++-
 .../autofixRepositoriesItem.tsx               |  68 +++--
 .../autofixRepositoriesList.tsx               |  41 ++-
 .../onboarding/configureCodeReviewStep.tsx    |  14 +-
 .../onboarding/configureDefaultsStep.tsx      |  18 +-
 .../configureRootCauseAnalysisStep.tsx        |  26 +-
 .../onboarding/onboardingLegacy.tsx           |  23 +-
 .../onboarding/repositorySelector.tsx         |   4 +-
 .../repositoryToProjectConfiguration.tsx      |  25 +-
 .../seerAutomation/onboarding/wrapUpStep.tsx  |   6 +-
 .../spikeProtectionProjects.tsx               |  88 +++----
 143 files changed, 1886 insertions(+), 2377 deletions(-)

diff --git a/static/app/components/assistant/guideAnchor.tsx b/static/app/components/assistant/guideAnchor.tsx
index 9660f81cfa716b..0abd2af11e2980 100644
--- a/static/app/components/assistant/guideAnchor.tsx
+++ b/static/app/components/assistant/guideAnchor.tsx
@@ -105,15 +105,12 @@ function BaseGuideAnchor({
     [onStepComplete]
   );
 
-  const handleDismiss = useCallback(
-    (e: React.MouseEvent) => {
-      e.stopPropagation();
-      if (currentGuide) {
-        dismissGuide(currentGuide.guide, step, orgId);
-      }
-    },
-    [currentGuide, orgId, step]
-  );
+  const handleDismiss = (e: React.MouseEvent) => {
+    e.stopPropagation();
+    if (currentGuide) {
+      dismissGuide(currentGuide.guide, step, orgId);
+    }
+  };
 
   if (!active) {
     return children ? children : null;
diff --git a/static/app/components/avatarChooser/useUploader.tsx b/static/app/components/avatarChooser/useUploader.tsx
index fcdf1099052ae6..3809a23754d5e7 100644
--- a/static/app/components/avatarChooser/useUploader.tsx
+++ b/static/app/components/avatarChooser/useUploader.tsx
@@ -41,34 +41,31 @@ export function useUploader({onSelect, minImageSize}: UseUploaderOptions) {
     [minImageSize]
   );
 
-  const onSelectFile = useCallback(
-    async (ev: React.ChangeEvent<HTMLInputElement>) => {
-      const file = ev.target.files?.[0];
+  const onSelectFile = async (ev: React.ChangeEvent<HTMLInputElement>) => {
+    const file = ev.target.files?.[0];
 
-      // No file selected (e.g. user clicked "cancel")
-      if (!file) {
-        return;
-      }
+    // No file selected (e.g. user clicked "cancel")
+    if (!file) {
+      return;
+    }
 
-      if (!/^image\//.test(file.type)) {
-        addErrorMessage(t('That is not a supported file type.'));
-        return;
-      }
-      const url = window.URL.createObjectURL(file);
-      const {height, width} = await getImageHeightAndWidth(url);
-      const sizeValidation = validateSize(height, width);
+    if (!/^image\//.test(file.type)) {
+      addErrorMessage(t('That is not a supported file type.'));
+      return;
+    }
+    const url = window.URL.createObjectURL(file);
+    const {height, width} = await getImageHeightAndWidth(url);
+    const sizeValidation = validateSize(height, width);
 
-      if (sizeValidation !== true) {
-        addErrorMessage(sizeValidation);
-        return;
-      }
+    if (sizeValidation !== true) {
+      addErrorMessage(sizeValidation);
+      return;
+    }
 
-      setObjectUrl(url);
-      onSelect(url);
-      ev.target.value = '';
-    },
-    [onSelect, validateSize]
-  );
+    setObjectUrl(url);
+    onSelect(url);
+    ev.target.value = '';
+  };
 
   const fileInput = (
     <input
diff --git a/static/app/components/clippedBox.tsx b/static/app/components/clippedBox.tsx
index 30210a8ef73504..2630b326bc83b3 100644
--- a/static/app/components/clippedBox.tsx
+++ b/static/app/components/clippedBox.tsx
@@ -161,51 +161,45 @@ export function ClippedBox(props: ClippedBoxProps) {
   const clipHeight = props.clipHeight || 200;
   const clipFlex = props.clipFlex || 28;
 
-  const handleReveal = useCallback(
-    (event: React.MouseEvent<HTMLElement>) => {
-      if (!wrapperRef.current) {
-        throw new Error('Cannot reveal clipped box without a wrapper ref');
-      }
-
-      event.stopPropagation();
-
-      revealAndDisconnectObserver({
-        contentRef,
-        wrapperRef,
-        revealRef,
-        observerRef,
-        clipHeight,
-        prefersReducedMotion: prefersReducedMotion ?? true,
-      });
-      if (typeof onReveal === 'function') {
-        onReveal();
+  const handleReveal = (event: React.MouseEvent<HTMLElement>) => {
+    if (!wrapperRef.current) {
+      throw new Error('Cannot reveal clipped box without a wrapper ref');
+    }
+
+    event.stopPropagation();
+
+    revealAndDisconnectObserver({
+      contentRef,
+      wrapperRef,
+      revealRef,
+      observerRef,
+      clipHeight,
+      prefersReducedMotion: prefersReducedMotion ?? true,
+    });
+    if (typeof onReveal === 'function') {
+      onReveal();
+    }
+
+    setClipped(false);
+  };
+
+  const handleCollapse = (event: React.MouseEvent<HTMLElement>) => {
+    event.stopPropagation();
+
+    if (wrapperRef.current && contentRef.current) {
+      if (prefersReducedMotion) {
+        wrapperRef.current.style.maxHeight = `${clipHeight}px`;
+      } else {
+        const currentHeight =
+          contentRef.current.clientHeight + calculateAddedHeight({wrapperRef});
+        wrapperRef.current.style.maxHeight = `${currentHeight}px`;
+        void wrapperRef.current.offsetHeight;
+        wrapperRef.current.style.maxHeight = `${clipHeight}px`;
       }
-
-      setClipped(false);
-    },
-    [clipHeight, onReveal, prefersReducedMotion]
-  );
-
-  const handleCollapse = useCallback(
-    (event: React.MouseEvent<HTMLElement>) => {
-      event.stopPropagation();
-
-      if (wrapperRef.current && contentRef.current) {
-        if (prefersReducedMotion) {
-          wrapperRef.current.style.maxHeight = `${clipHeight}px`;
-        } else {
-          const currentHeight =
-            contentRef.current.clientHeight + calculateAddedHeight({wrapperRef});
-          wrapperRef.current.style.maxHeight = `${currentHeight}px`;
-          void wrapperRef.current.offsetHeight;
-          wrapperRef.current.style.maxHeight = `${clipHeight}px`;
-        }
-      }
-      revealRef.current = false;
-      setClipped(true);
-    },
-    [clipHeight, prefersReducedMotion]
-  );
+    }
+    revealRef.current = false;
+    setClipped(true);
+  };
 
   const onWrapperRef = useCallback(
     (node: HTMLDivElement | null) => {
diff --git a/static/app/components/core/input/numberDragInput.tsx b/static/app/components/core/input/numberDragInput.tsx
index 4d106b844670c0..3a6e3059630579 100644
--- a/static/app/components/core/input/numberDragInput.tsx
+++ b/static/app/components/core/input/numberDragInput.tsx
@@ -78,40 +78,34 @@ export function NumberDragInput({
     document.removeEventListener('pointerup', onPointerUp);
   }, [onPointerMove]);
 
-  const onPointerDown = useCallback(
-    (event: React.PointerEvent<HTMLElement>) => {
-      if (event.button !== 0) {
-        return;
-      }
-
-      // Request pointer lock and add move and pointer up handlers
-      // that release the lock and cleanup handlers
-      event.currentTarget.requestPointerLock();
-      document.addEventListener('pointermove', onPointerMove);
-      document.addEventListener('pointerup', onPointerUp);
-    },
-    [onPointerMove, onPointerUp]
-  );
+  const onPointerDown = (event: React.PointerEvent<HTMLElement>) => {
+    if (event.button !== 0) {
+      return;
+    }
+
+    // Request pointer lock and add move and pointer up handlers
+    // that release the lock and cleanup handlers
+    event.currentTarget.requestPointerLock();
+    document.addEventListener('pointermove', onPointerMove);
+    document.addEventListener('pointerup', onPointerUp);
+  };
 
   const onKeyDownProp = props.onKeyDown;
-  const onKeyDown = useCallback(
-    (event: React.KeyboardEvent<HTMLInputElement>) => {
-      onKeyDownProp?.(event);
-
-      if (!inputRef.current || (event.key !== 'ArrowUp' && event.key !== 'ArrowDown')) {
-        return;
-      }
-
-      event.preventDefault();
-      const value = parseFloat(inputRef.current.value);
-      const step = parseFloat(props.step?.toString() ?? '1');
-      const min = props.min ?? Number.NEGATIVE_INFINITY;
-      const max = props.max ?? Number.POSITIVE_INFINITY;
-      const newValue = clamp(value + (event.key === 'ArrowUp' ? step : -step), min, max);
-      setInputValueAndDispatchChange(inputRef.current, newValue.toString());
-    },
-    [onKeyDownProp, props.min, props.max, props.step]
-  );
+  const onKeyDown = (event: React.KeyboardEvent<HTMLInputElement>) => {
+    onKeyDownProp?.(event);
+
+    if (!inputRef.current || (event.key !== 'ArrowUp' && event.key !== 'ArrowDown')) {
+      return;
+    }
+
+    event.preventDefault();
+    const value = parseFloat(inputRef.current.value);
+    const step = parseFloat(props.step?.toString() ?? '1');
+    const min = props.min ?? Number.NEGATIVE_INFINITY;
+    const max = props.max ?? Number.POSITIVE_INFINITY;
+    const newValue = clamp(value + (event.key === 'ArrowUp' ? step : -step), min, max);
+    setInputValueAndDispatchChange(inputRef.current, newValue.toString());
+  };
 
   return (
     <InputGroup>
diff --git a/static/app/components/core/inspector.tsx b/static/app/components/core/inspector.tsx
index ba7557cd8c1cf4..c756aff7c81a5b 100644
--- a/static/app/components/core/inspector.tsx
+++ b/static/app/components/core/inspector.tsx
@@ -282,25 +282,22 @@ export function SentryComponentInspector() {
   }, [state.trace]);
 
   const {ref: contextMenuRef, ...contextMenuProps} = {...contextMenu.getMenuProps()};
-  const positionContextMenuOnMountRef = useCallback(
-    (ref: HTMLDivElement | null) => {
-      contextMenuRef(ref);
-
-      if (ref) {
-        const position = computeTooltipPosition(
-          {
-            x: tooltipPositionRef.current?.mouse.x ?? 0,
-            y: tooltipPositionRef.current?.mouse.y ?? 0,
-          },
-          ref
-        );
+  const positionContextMenuOnMountRef = (ref: HTMLDivElement | null) => {
+    contextMenuRef(ref);
+
+    if (ref) {
+      const position = computeTooltipPosition(
+        {
+          x: tooltipPositionRef.current?.mouse.x ?? 0,
+          y: tooltipPositionRef.current?.mouse.y ?? 0,
+        },
+        ref
+      );
 
-        ref.style.left = `${position.left}px`;
-        ref.style.top = `${position.top}px`;
-      }
-    },
-    [contextMenuRef]
-  );
+      ref.style.left = `${position.left}px`;
+      ref.style.top = `${position.top}px`;
+    }
+  };
 
   const storybookFiles = useStoryBookFiles();
   const storybookFilesLookup = useMemo(
diff --git a/static/app/components/events/autofix/autofixStepFeedback.tsx b/static/app/components/events/autofix/autofixStepFeedback.tsx
index 8d2a026baaa4c8..648ab698579b5e 100644
--- a/static/app/components/events/autofix/autofixStepFeedback.tsx
+++ b/static/app/components/events/autofix/autofixStepFeedback.tsx
@@ -1,7 +1,7 @@
-import {useCallback, useState} from 'react';
+import {useState} from 'react';
 
-import {Button} from '@sentry/scraps/button';
 import type {ButtonProps} from '@sentry/scraps/button';
+import {Button} from '@sentry/scraps/button';
 import {Flex} from '@sentry/scraps/layout';
 import {Text} from '@sentry/scraps/text';
 
@@ -34,27 +34,24 @@ export function AutofixStepFeedback({
   const organization = useOrganization();
   const user = useUser();
 
-  const handleFeedback = useCallback(
-    (positive: boolean, e?: React.MouseEvent) => {
-      if (onFeedbackClick && e) {
-        onFeedbackClick(e);
-      }
+  const handleFeedback = (positive: boolean, e?: React.MouseEvent) => {
+    if (onFeedbackClick && e) {
+      onFeedbackClick(e);
+    }
 
-      const analyticsData = {
-        step_type: stepType,
-        positive,
-        group_id: groupId,
-        autofix_run_id: runId,
-        user_id: user.id,
-        organization,
-      };
+    const analyticsData = {
+      step_type: stepType,
+      positive,
+      group_id: groupId,
+      autofix_run_id: runId,
+      user_id: user.id,
+      organization,
+    };
 
-      trackAnalytics('seer.autofix.feedback_submitted', analyticsData);
+    trackAnalytics('seer.autofix.feedback_submitted', analyticsData);
 
-      setFeedbackSubmitted(true);
-    },
-    [stepType, groupId, runId, organization, user, onFeedbackClick]
-  );
+    setFeedbackSubmitted(true);
+  };
 
   if (feedbackSubmitted) {
     return (
diff --git a/static/app/components/events/autofix/codingAgentIntegrationCta.tsx b/static/app/components/events/autofix/codingAgentIntegrationCta.tsx
index c7728e66dc382c..584b095b10dda0 100644
--- a/static/app/components/events/autofix/codingAgentIntegrationCta.tsx
+++ b/static/app/components/events/autofix/codingAgentIntegrationCta.tsx
@@ -1,5 +1,3 @@
-import {useCallback} from 'react';
-
 import {Button, LinkButton} from '@sentry/scraps/button';
 import {Container, Flex} from '@sentry/scraps/layout';
 import {ExternalLink, Link} from '@sentry/scraps/link';
@@ -61,7 +59,7 @@ export function makeCodingAgentIntegrationCta(config: AgentConfig) {
     const isConfigured =
       preference?.automation_handoff?.target === config.target && isAutomationEnabled;
 
-    const handleInstallClick = useCallback(() => {
+    const handleInstallClick = () => {
       trackAnalytics('coding_integration.install_clicked', {
         organization,
         project_slug: project.slug,
@@ -69,9 +67,9 @@ export function makeCodingAgentIntegrationCta(config: AgentConfig) {
         source: 'cta',
         user_id: user.id,
       });
-    }, [organization, project.slug, user.id]);
+    };
 
-    const handleSetupClick = useCallback(async () => {
+    const handleSetupClick = async () => {
       if (!integration?.id) {
         throw new Error(`${config.displayName} integration not found`);
       }
@@ -104,17 +102,7 @@ export function makeCodingAgentIntegrationCta(config: AgentConfig) {
           integration_id: parseInt(integration.id, 10),
         },
       });
-    }, [
-      organization,
-      project.slug,
-      project.seerScannerAutomation,
-      project.autofixAutomationTuning,
-      updateProjectSeerPreferences,
-      updateProjectAutomation,
-      preference?.repositories,
-      integration,
-      user.id,
-    ]);
+    };
 
     if (!hasFeatureFlag) {
       return null;
diff --git a/static/app/components/events/autofix/githubCopilotIntegrationCta.tsx b/static/app/components/events/autofix/githubCopilotIntegrationCta.tsx
index 38f2b214021fe7..2135c51d52c6d0 100644
--- a/static/app/components/events/autofix/githubCopilotIntegrationCta.tsx
+++ b/static/app/components/events/autofix/githubCopilotIntegrationCta.tsx
@@ -1,5 +1,3 @@
-import {useCallback} from 'react';
-
 import {LinkButton} from '@sentry/scraps/button';
 import {Container, Flex} from '@sentry/scraps/layout';
 import {Heading, Text} from '@sentry/scraps/text';
@@ -21,7 +19,7 @@ export function GithubCopilotIntegrationCta() {
     organizationIntegrationsCodingAgents(organization)
   );
 
-  const handleInstallClick = useCallback(() => {
+  const handleInstallClick = () => {
     trackAnalytics('coding_integration.install_clicked', {
       organization,
       project_slug: '', // GitHub Copilot CTA is not project-specific
@@ -29,7 +27,7 @@ export function GithubCopilotIntegrationCta() {
       source: 'cta',
       user_id: user.id,
     });
-  }, [organization, user.id]);
+  };
 
   const githubCopilotIntegration = codingAgentIntegrations?.integrations.find(
     integration => integration.provider === 'github_copilot'
diff --git a/static/app/components/events/breadcrumbs/breadcrumbsDataSection.tsx b/static/app/components/events/breadcrumbs/breadcrumbsDataSection.tsx
index 54b4a3f39eb8e1..a725ae20a85378 100644
--- a/static/app/components/events/breadcrumbs/breadcrumbsDataSection.tsx
+++ b/static/app/components/events/breadcrumbs/breadcrumbsDataSection.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useMemo, useRef, useState} from 'react';
+import {useMemo, useRef, useState} from 'react';
 import {useTheme} from '@emotion/react';
 import styled from '@emotion/styled';
 
@@ -79,44 +79,41 @@ export function BreadcrumbsDataSection({
     [summaryCrumbs, timeDisplay]
   );
 
-  const onViewAllBreadcrumbs = useCallback(
-    (focusControl?: BreadcrumbControlOptions) => {
-      trackAnalytics('breadcrumbs.issue_details.drawer_opened', {
-        control: focusControl ?? 'view all',
-        organization,
-      });
-      openDrawer(
-        () => (
-          <BreadcrumbsDrawer
-            breadcrumbs={enhancedCrumbs}
-            focusControl={focusControl}
-            project={project}
-            event={event}
-            group={group}
-          />
-        ),
-        {
-          ariaLabel: 'breadcrumb drawer',
-          drawerKey: 'breadcrumbs-drawer',
-          // We prevent a click on the 'View All' button from closing the drawer so that
-          // we don't reopen it immediately, and instead let the button handle this itself.
-          shouldCloseOnInteractOutside: element => {
-            const viewAllButton = viewAllButtonRef.current;
-            if (viewAllButton?.contains(element)) {
-              return false;
-            }
-            // Third-party packages (e.g. Pendo) use a container with id "pendo-guide-container".
-            // If the click is inside that container, treat it as an internal click.
-            if (element.closest('#pendo-guide-container')) {
-              return false;
-            }
-            return true;
-          },
-        }
-      );
-    },
-    [group, event, project, openDrawer, enhancedCrumbs, organization]
-  );
+  const onViewAllBreadcrumbs = (focusControl?: BreadcrumbControlOptions) => {
+    trackAnalytics('breadcrumbs.issue_details.drawer_opened', {
+      control: focusControl ?? 'view all',
+      organization,
+    });
+    openDrawer(
+      () => (
+        <BreadcrumbsDrawer
+          breadcrumbs={enhancedCrumbs}
+          focusControl={focusControl}
+          project={project}
+          event={event}
+          group={group}
+        />
+      ),
+      {
+        ariaLabel: 'breadcrumb drawer',
+        drawerKey: 'breadcrumbs-drawer',
+        // We prevent a click on the 'View All' button from closing the drawer so that
+        // we don't reopen it immediately, and instead let the button handle this itself.
+        shouldCloseOnInteractOutside: element => {
+          const viewAllButton = viewAllButtonRef.current;
+          if (viewAllButton?.contains(element)) {
+            return false;
+          }
+          // Third-party packages (e.g. Pendo) use a container with id "pendo-guide-container".
+          // If the click is inside that container, treat it as an internal click.
+          if (element.closest('#pendo-guide-container')) {
+            return false;
+          }
+          return true;
+        },
+      }
+    );
+  };
 
   if (enhancedCrumbs.length === 0) {
     return null;
diff --git a/static/app/components/events/eventTagsAndScreenshot/tags.tsx b/static/app/components/events/eventTagsAndScreenshot/tags.tsx
index 0c590297042e5c..a48866ad68acad 100644
--- a/static/app/components/events/eventTagsAndScreenshot/tags.tsx
+++ b/static/app/components/events/eventTagsAndScreenshot/tags.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useMemo, useState} from 'react';
+import {useMemo, useState} from 'react';
 import styled from '@emotion/styled';
 
 import {Grid} from '@sentry/scraps/layout';
@@ -41,9 +41,9 @@ export function EventTagsDataSection({
   const sentryTags = getSentryDefaultTags();
 
   const [tagFilter, setTagFilter] = useState<TagFilter>(TagFilter.ALL);
-  const handleTagFilterChange = useCallback((value: TagFilter) => {
+  const handleTagFilterChange = (value: TagFilter) => {
     setTagFilter(value);
-  }, []);
+  };
 
   const tagsWithMeta = useMemo(() => {
     return associateTagsWithMeta({tags: event.tags, meta: event._meta?.tags});
diff --git a/static/app/components/events/featureFlags/eventFeatureFlagSection.tsx b/static/app/components/events/featureFlags/eventFeatureFlagSection.tsx
index 22ccb1d57d2902..5e4c5c12dda783 100644
--- a/static/app/components/events/featureFlags/eventFeatureFlagSection.tsx
+++ b/static/app/components/events/featureFlags/eventFeatureFlagSection.tsx
@@ -170,39 +170,36 @@ function BaseEventFeatureFlagList({event, group, project}: EventFeatureFlagSecti
     });
   }, [suspectFlagNames, eventFlags, generateAction]);
 
-  const onViewAllFlags = useCallback(
-    (focusControl?: FlagControlOptions) => {
-      trackAnalytics('flags.view-all-clicked', {
-        organization,
-      });
-      openDrawer(
-        () => (
-          <EventFeatureFlagDrawer
-            group={group}
-            event={event}
-            project={project}
-            hydratedFlags={hydratedFlags}
-            initialOrderBy={orderBy}
-            focusControl={focusControl}
-          />
-        ),
-        {
-          ariaLabel: t('Feature flags drawer'),
-          drawerKey: 'feature-flags-drawer',
-          // We prevent a click on the 'View All' button from closing the drawer so that
-          // we don't reopen it immediately, and instead let the button handle this itself.
-          shouldCloseOnInteractOutside: element => {
-            const viewAllButton = viewAllButtonRef.current;
-            if (viewAllButton?.contains(element)) {
-              return false;
-            }
-            return true;
-          },
-        }
-      );
-    },
-    [openDrawer, event, group, project, hydratedFlags, organization, orderBy]
-  );
+  const onViewAllFlags = (focusControl?: FlagControlOptions) => {
+    trackAnalytics('flags.view-all-clicked', {
+      organization,
+    });
+    openDrawer(
+      () => (
+        <EventFeatureFlagDrawer
+          group={group}
+          event={event}
+          project={project}
+          hydratedFlags={hydratedFlags}
+          initialOrderBy={orderBy}
+          focusControl={focusControl}
+        />
+      ),
+      {
+        ariaLabel: t('Feature flags drawer'),
+        drawerKey: 'feature-flags-drawer',
+        // We prevent a click on the 'View All' button from closing the drawer so that
+        // we don't reopen it immediately, and instead let the button handle this itself.
+        shouldCloseOnInteractOutside: element => {
+          const viewAllButton = viewAllButtonRef.current;
+          if (viewAllButton?.contains(element)) {
+            return false;
+          }
+          return true;
+        },
+      }
+    );
+  };
 
   useEffect(() => {
     if (hasFlags) {
diff --git a/static/app/components/events/highlights/highlightsDataSection.tsx b/static/app/components/events/highlights/highlightsDataSection.tsx
index 04ff34a4898181..954a8dc9d16aa0 100644
--- a/static/app/components/events/highlights/highlightsDataSection.tsx
+++ b/static/app/components/events/highlights/highlightsDataSection.tsx
@@ -1,5 +1,5 @@
-import {useCallback, useMemo, useRef} from 'react';
-import {css, useTheme, type Theme} from '@emotion/react';
+import {useMemo, useRef} from 'react';
+import {css, type Theme, useTheme} from '@emotion/react';
 import styled from '@emotion/styled';
 
 import {Button} from '@sentry/scraps/button';
@@ -63,7 +63,7 @@ function useOpenEditHighlightsModal({
     [isProjectAdmin]
   );
 
-  const openEditHighlightsModal = useCallback(() => {
+  const openEditHighlightsModal = () => {
     trackAnalytics('highlights.issue_details.edit_clicked', {organization});
     openModal(
       deps => (
@@ -78,7 +78,7 @@ function useOpenEditHighlightsModal({
       ),
       {modalCss: highlightModalCss(theme)}
     );
-  }, [organization, detailedProject, event, theme]);
+  };
 
   return {openEditHighlightsModal, editProps};
 }
diff --git a/static/app/components/events/metrics/metricsSection.tsx b/static/app/components/events/metrics/metricsSection.tsx
index c5a661f39c714a..f6f6e150910ea1 100644
--- a/static/app/components/events/metrics/metricsSection.tsx
+++ b/static/app/components/events/metrics/metricsSection.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useEffect, useRef} from 'react';
+import {useEffect, useRef} from 'react';
 
 import {Button} from '@sentry/scraps/button';
 import {Flex} from '@sentry/scraps/layout';
@@ -78,26 +78,23 @@ function MetricsSectionContent({
     ? result.data.slice(0, NUMBER_ABBREVIATED_METRICS)
     : undefined;
 
-  const onOpenMetricsDrawer = useCallback(
-    (e: React.MouseEvent) => {
-      e.stopPropagation();
-      trackAnalytics('metrics.issue_details.drawer_opened', {
-        organization,
-      });
+  const onOpenMetricsDrawer = (e: React.MouseEvent) => {
+    e.stopPropagation();
+    trackAnalytics('metrics.issue_details.drawer_opened', {
+      organization,
+    });
 
-      navigate(
-        {
-          ...location,
-          query: {
-            ...location.query,
-            [METRICS_DRAWER_QUERY_PARAM]: 'true',
-          },
+    navigate(
+      {
+        ...location,
+        query: {
+          ...location.query,
+          [METRICS_DRAWER_QUERY_PARAM]: 'true',
         },
-        {replace: true}
-      );
-    },
-    [navigate, location, organization]
-  );
+      },
+      {replace: true}
+    );
+  };
 
   useEffect(() => {
     const shouldOpenDrawer = location.query[METRICS_DRAWER_QUERY_PARAM] === 'true';
diff --git a/static/app/components/events/suspectCommitFeedback.tsx b/static/app/components/events/suspectCommitFeedback.tsx
index d11bdc36e58210..093dc0db486c41 100644
--- a/static/app/components/events/suspectCommitFeedback.tsx
+++ b/static/app/components/events/suspectCommitFeedback.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useState} from 'react';
+import {useState} from 'react';
 import styled from '@emotion/styled';
 
 import {Button} from '@sentry/scraps/button';
@@ -22,21 +22,18 @@ export function SuspectCommitFeedback({
   const [feedbackSubmitted, setFeedbackSubmitted] = useState(false);
   const user = useUser();
 
-  const handleFeedback = useCallback(
-    (isCorrect: boolean) => {
-      const analyticsData = {
-        choice_selected: isCorrect,
-        group_owner_id: groupOwnerId,
-        user_id: user.id,
-        organization,
-      };
+  const handleFeedback = (isCorrect: boolean) => {
+    const analyticsData = {
+      choice_selected: isCorrect,
+      group_owner_id: groupOwnerId,
+      user_id: user.id,
+      organization,
+    };
 
-      trackAnalytics('suspect_commit.feedback_submitted', analyticsData);
+    trackAnalytics('suspect_commit.feedback_submitted', analyticsData);
 
-      setFeedbackSubmitted(true);
-    },
-    [groupOwnerId, organization, user]
-  );
+    setFeedbackSubmitted(true);
+  };
 
   if (feedbackSubmitted) {
     return (
diff --git a/static/app/components/events/traceEventDataSection.tsx b/static/app/components/events/traceEventDataSection.tsx
index c1e18ac0c6d24b..8f58ce2247f8a3 100644
--- a/static/app/components/events/traceEventDataSection.tsx
+++ b/static/app/components/events/traceEventDataSection.tsx
@@ -84,154 +84,145 @@ export function TraceEventDataSection({
 
   const isMobile = isMobilePlatform(platform);
 
-  const handleFilterFramesChange = useCallback(
-    (val: 'full' | 'relevant') => {
-      const isFullOptionClicked = val === 'full';
+  const handleFilterFramesChange = (val: 'full' | 'relevant') => {
+    const isFullOptionClicked = val === 'full';
 
-      trackAnalytics(
-        isFullOptionClicked
-          ? 'stack-trace.full_stack_trace_clicked'
-          : 'stack-trace.most_relevant_clicked',
-        {
-          organization,
-          project_slug: projectSlug,
-          platform,
-          is_mobile: isMobile,
-        }
-      );
-
-      setIsFullStackTrace(isFullOptionClicked);
-    },
-    [organization, platform, projectSlug, isMobile, setIsFullStackTrace]
-  );
+    trackAnalytics(
+      isFullOptionClicked
+        ? 'stack-trace.full_stack_trace_clicked'
+        : 'stack-trace.most_relevant_clicked',
+      {
+        organization,
+        project_slug: projectSlug,
+        platform,
+        is_mobile: isMobile,
+      }
+    );
 
-  const handleSortByChange = useCallback(
-    (val: keyof typeof sortByOptions) => {
-      const isRecentFirst = val === 'recent-first';
+    setIsFullStackTrace(isFullOptionClicked);
+  };
 
-      trackAnalytics(
-        isRecentFirst
-          ? 'stack-trace.sort_option_recent_first_clicked'
-          : 'stack-trace.sort_option_recent_last_clicked',
-        {
-          organization,
-          project_slug: projectSlug,
-          platform,
-          is_mobile: isMobile,
-        }
-      );
+  const handleSortByChange = (val: keyof typeof sortByOptions) => {
+    const isRecentFirst = val === 'recent-first';
 
-      setIsNewestFramesFirst(isRecentFirst);
-    },
-    [organization, platform, projectSlug, isMobile, setIsNewestFramesFirst]
-  );
-
-  const handleDisplayChange = useCallback(
-    (vals: typeof displayOptions) => {
-      if (vals.includes('raw-stack-trace')) {
-        trackAnalytics('stack-trace.display_option_raw_stack_trace_clicked', {
-          organization,
-          project_slug: projectSlug,
-          platform,
-          is_mobile: isMobile,
-          checked: true,
-        });
-      } else if (displayOptions.includes('raw-stack-trace')) {
-        trackAnalytics('stack-trace.display_option_raw_stack_trace_clicked', {
-          organization,
-          project_slug: projectSlug,
-          platform,
-          is_mobile: isMobile,
-          checked: false,
-        });
+    trackAnalytics(
+      isRecentFirst
+        ? 'stack-trace.sort_option_recent_first_clicked'
+        : 'stack-trace.sort_option_recent_last_clicked',
+      {
+        organization,
+        project_slug: projectSlug,
+        platform,
+        is_mobile: isMobile,
       }
+    );
 
-      if (vals.includes('absolute-addresses')) {
-        trackAnalytics('stack-trace.display_option_absolute_addresses_clicked', {
-          organization,
-          project_slug: projectSlug,
-          platform,
-          is_mobile: isMobile,
-          checked: true,
-        });
-      } else if (displayOptions.includes('absolute-addresses')) {
-        trackAnalytics('stack-trace.display_option_absolute_addresses_clicked', {
-          organization,
-          project_slug: projectSlug,
-          platform,
-          is_mobile: isMobile,
-          checked: false,
-        });
-      }
+    setIsNewestFramesFirst(isRecentFirst);
+  };
+
+  const handleDisplayChange = (vals: typeof displayOptions) => {
+    if (vals.includes('raw-stack-trace')) {
+      trackAnalytics('stack-trace.display_option_raw_stack_trace_clicked', {
+        organization,
+        project_slug: projectSlug,
+        platform,
+        is_mobile: isMobile,
+        checked: true,
+      });
+    } else if (displayOptions.includes('raw-stack-trace')) {
+      trackAnalytics('stack-trace.display_option_raw_stack_trace_clicked', {
+        organization,
+        project_slug: projectSlug,
+        platform,
+        is_mobile: isMobile,
+        checked: false,
+      });
+    }
 
-      if (vals.includes('absolute-file-paths')) {
-        trackAnalytics('stack-trace.display_option_absolute_file_paths_clicked', {
-          organization,
-          project_slug: projectSlug,
-          platform,
-          is_mobile: isMobile,
-          checked: true,
-        });
-      } else if (displayOptions.includes('absolute-file-paths')) {
-        trackAnalytics('stack-trace.display_option_absolute_file_paths_clicked', {
-          organization,
-          project_slug: projectSlug,
-          platform,
-          is_mobile: isMobile,
-          checked: false,
-        });
-      }
+    if (vals.includes('absolute-addresses')) {
+      trackAnalytics('stack-trace.display_option_absolute_addresses_clicked', {
+        organization,
+        project_slug: projectSlug,
+        platform,
+        is_mobile: isMobile,
+        checked: true,
+      });
+    } else if (displayOptions.includes('absolute-addresses')) {
+      trackAnalytics('stack-trace.display_option_absolute_addresses_clicked', {
+        organization,
+        project_slug: projectSlug,
+        platform,
+        is_mobile: isMobile,
+        checked: false,
+      });
+    }
 
-      if (vals.includes('minified')) {
-        trackAnalytics(
-          platform.startsWith('javascript')
-            ? 'stack-trace.display_option_minified_clicked'
-            : 'stack-trace.display_option_unsymbolicated_clicked',
-          {
-            organization,
-            project_slug: projectSlug,
-            platform,
-            is_mobile: isMobile,
-            checked: true,
-          }
-        );
-      } else if (displayOptions.includes('minified')) {
-        trackAnalytics(
-          platform.startsWith('javascript')
-            ? 'stack-trace.display_option_minified_clicked'
-            : 'stack-trace.display_option_unsymbolicated_clicked',
-          {
-            organization,
-            project_slug: projectSlug,
-            platform,
-            is_mobile: isMobile,
-            checked: false,
-          }
-        );
-      }
+    if (vals.includes('absolute-file-paths')) {
+      trackAnalytics('stack-trace.display_option_absolute_file_paths_clicked', {
+        organization,
+        project_slug: projectSlug,
+        platform,
+        is_mobile: isMobile,
+        checked: true,
+      });
+    } else if (displayOptions.includes('absolute-file-paths')) {
+      trackAnalytics('stack-trace.display_option_absolute_file_paths_clicked', {
+        organization,
+        project_slug: projectSlug,
+        platform,
+        is_mobile: isMobile,
+        checked: false,
+      });
+    }
 
-      if (vals.includes('verbose-function-names')) {
-        trackAnalytics('stack-trace.display_option_verbose_function_names_clicked', {
+    if (vals.includes('minified')) {
+      trackAnalytics(
+        platform.startsWith('javascript')
+          ? 'stack-trace.display_option_minified_clicked'
+          : 'stack-trace.display_option_unsymbolicated_clicked',
+        {
           organization,
           project_slug: projectSlug,
           platform,
           is_mobile: isMobile,
           checked: true,
-        });
-      } else if (displayOptions.includes('verbose-function-names')) {
-        trackAnalytics('stack-trace.display_option_verbose_function_names_clicked', {
+        }
+      );
+    } else if (displayOptions.includes('minified')) {
+      trackAnalytics(
+        platform.startsWith('javascript')
+          ? 'stack-trace.display_option_minified_clicked'
+          : 'stack-trace.display_option_unsymbolicated_clicked',
+        {
           organization,
           project_slug: projectSlug,
           platform,
           is_mobile: isMobile,
           checked: false,
-        });
-      }
+        }
+      );
+    }
 
-      setDisplayOptions(vals);
-    },
-    [organization, platform, projectSlug, isMobile, displayOptions, setDisplayOptions]
-  );
+    if (vals.includes('verbose-function-names')) {
+      trackAnalytics('stack-trace.display_option_verbose_function_names_clicked', {
+        organization,
+        project_slug: projectSlug,
+        platform,
+        is_mobile: isMobile,
+        checked: true,
+      });
+    } else if (displayOptions.includes('verbose-function-names')) {
+      trackAnalytics('stack-trace.display_option_verbose_function_names_clicked', {
+        organization,
+        project_slug: projectSlug,
+        platform,
+        is_mobile: isMobile,
+        checked: false,
+      });
+    }
+
+    setDisplayOptions(vals);
+  };
 
   const handleCopyRawStacktrace = useCallback(() => {
     trackAnalytics('stack-trace.copy_raw_clicked', {
diff --git a/static/app/components/externalIssues/externalIssueForm.tsx b/static/app/components/externalIssues/externalIssueForm.tsx
index 1909ad8c008504..7df49555d65ef5 100644
--- a/static/app/components/externalIssues/externalIssueForm.tsx
+++ b/static/app/components/externalIssues/externalIssueForm.tsx
@@ -253,13 +253,10 @@ export function ExternalIssueForm({
     }
   }, [isPending, isError, loadSpan, organization, group, integration, hasTrackedLoad]);
 
-  const handleClick = useCallback(
-    (newAction: ExternalIssueAction) => {
-      setAction(newAction);
-      refetch();
-    },
-    [refetch]
-  );
+  const handleClick = (newAction: ExternalIssueAction) => {
+    setAction(newAction);
+    refetch();
+  };
 
   const handleSubmit = useCallback(
     async (values: Record<string, unknown>) => {
diff --git a/static/app/components/feedback/feedbackItem/feedbackItemUsername.tsx b/static/app/components/feedback/feedbackItem/feedbackItemUsername.tsx
index dbe388548939ac..17b98d813a6175 100644
--- a/static/app/components/feedback/feedbackItem/feedbackItemUsername.tsx
+++ b/static/app/components/feedback/feedbackItem/feedbackItemUsername.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback, useId, type CSSProperties} from 'react';
+import {type CSSProperties, Fragment, useId} from 'react';
 import styled from '@emotion/styled';
 
 import {LinkButton} from '@sentry/scraps/button';
@@ -35,14 +35,14 @@ export function FeedbackItemUsername({className, feedbackIssue, style}: Props) {
 
   const userNodeId = useId();
 
-  const handleSelectText = useCallback(() => {
+  const handleSelectText = () => {
     const node = document.getElementById(userNodeId);
     if (!node) {
       return;
     }
 
     selectText(node);
-  }, [userNodeId]);
+  };
 
   const {copy} = useCopyToClipboard();
 
diff --git a/static/app/components/forms/form.tsx b/static/app/components/forms/form.tsx
index 1502ee0f2127a3..9547ab71875de8 100644
--- a/static/app/components/forms/form.tsx
+++ b/static/app/components/forms/form.tsx
@@ -197,38 +197,22 @@ export function Form({
     [formModel, onSubmitError]
   );
 
-  const handleSubmit = useCallback(
-    (e: any) => {
-      if (!skipPreventDefault) {
-        e.preventDefault();
-      }
-      if (formModel.isSaving) {
-        return;
-      }
+  const handleSubmit = (e: any) => {
+    if (!skipPreventDefault) {
+      e.preventDefault();
+    }
+    if (formModel.isSaving) {
+      return;
+    }
 
-      onPreSubmit?.();
+    onPreSubmit?.();
 
-      onSubmit?.(
-        formModel.getData(),
-        handleSubmitSuccess,
-        handleSubmitError,
-        e,
-        formModel
-      );
+    onSubmit?.(formModel.getData(), handleSubmitSuccess, handleSubmitError, e, formModel);
 
-      if (!onSubmit) {
-        formModel.saveForm();
-      }
-    },
-    [
-      formModel,
-      handleSubmitError,
-      handleSubmitSuccess,
-      onPreSubmit,
-      onSubmit,
-      skipPreventDefault,
-    ]
-  );
+    if (!onSubmit) {
+      formModel.saveForm();
+    }
+  };
 
   const shouldShowFooter = typeof hideFooter === 'undefined' ? !saveOnBlur : !hideFooter;
 
diff --git a/static/app/components/groupPreviewTooltip/groupPreviewHovercard.tsx b/static/app/components/groupPreviewTooltip/groupPreviewHovercard.tsx
index 2bd4e684f6b421..564dd842373218 100644
--- a/static/app/components/groupPreviewTooltip/groupPreviewHovercard.tsx
+++ b/static/app/components/groupPreviewTooltip/groupPreviewHovercard.tsx
@@ -1,5 +1,4 @@
 import type {ComponentProps} from 'react';
-import {useCallback} from 'react';
 import {css, useTheme} from '@emotion/react';
 import styled from '@emotion/styled';
 
@@ -18,10 +17,7 @@ export function GroupPreviewHovercard({
   ...props
 }: GroupPreviewHovercardProps) {
   const theme = useTheme();
-  const handleStackTracePreviewClick = useCallback(
-    (e: React.MouseEvent) => e.stopPropagation(),
-    []
-  );
+  const handleStackTracePreviewClick = (e: React.MouseEvent) => e.stopPropagation();
 
   // No need to preview on hover for small devices
   const shouldNotPreview = useMedia(`(max-width: ${theme.breakpoints.lg})`);
diff --git a/static/app/components/modals/explore/saveQueryModal.tsx b/static/app/components/modals/explore/saveQueryModal.tsx
index ebd50fd47f14eb..c3907fcade9399 100644
--- a/static/app/components/modals/explore/saveQueryModal.tsx
+++ b/static/app/components/modals/explore/saveQueryModal.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback, useState} from 'react';
+import {Fragment, useState} from 'react';
 import styled from '@emotion/styled';
 import * as Sentry from '@sentry/react';
 
@@ -49,7 +49,7 @@ function SaveQueryModal({
 
   const setQueryParamsSavedQuery = useSetQueryParamsSavedQuery();
 
-  const onSave = useCallback(async () => {
+  const onSave = async () => {
     try {
       setIsSaving(true);
       addLoadingMessage(t('Saving query...'));
@@ -82,17 +82,7 @@ function SaveQueryModal({
     } finally {
       setIsSaving(false);
     }
-  }, [
-    saveQuery,
-    name,
-    starred,
-    setQueryParamsSavedQuery,
-    closeModal,
-    organization,
-    initialName,
-    source,
-    traceItemDataset,
-  ]);
+  };
 
   return (
     <Fragment>
diff --git a/static/app/components/modals/inviteMissingMembersModal/index.tsx b/static/app/components/modals/inviteMissingMembersModal/index.tsx
index d7bd9d558c5a64..8582924086b3d3 100644
--- a/static/app/components/modals/inviteMissingMembersModal/index.tsx
+++ b/static/app/components/modals/inviteMissingMembersModal/index.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback, useMemo, useState} from 'react';
+import {Fragment, useMemo, useState} from 'react';
 import {css} from '@emotion/react';
 import styled from '@emotion/styled';
 
@@ -62,44 +62,35 @@ export function InviteMissingMembersModal({
     [allowedRoles]
   );
 
-  const setRole = useCallback(
-    (role: string, index: number) => {
-      setMemberInvites(prevInvites => {
-        const invites = prevInvites.map(i => ({...i}));
-        invites[index]!.role = role;
-        if (!allowedRolesMap[role]!.isTeamRolesAllowed) {
-          invites[index]!.teamSlugs = new Set([]);
-        }
-        return invites;
-      });
-    },
-    [allowedRolesMap]
-  );
+  const setRole = (role: string, index: number) => {
+    setMemberInvites(prevInvites => {
+      const invites = prevInvites.map(i => ({...i}));
+      invites[index]!.role = role;
+      if (!allowedRolesMap[role]!.isTeamRolesAllowed) {
+        invites[index]!.teamSlugs = new Set([]);
+      }
+      return invites;
+    });
+  };
 
-  const setTeams = useCallback((teamSlugs: string[], index: number) => {
+  const setTeams = (teamSlugs: string[], index: number) => {
     setMemberInvites(prevInvites => {
       const invites = prevInvites.map(i => ({...i}));
       invites[index]!.teamSlugs = new Set(teamSlugs);
       return invites;
     });
-  }, []);
-
-  const selectAll = useCallback(
-    (checked: boolean) => {
-      const selectedMembers = memberInvites.map(m => ({...m, selected: checked}));
-      setMemberInvites(selectedMembers);
-    },
-    [memberInvites]
-  );
+  };
 
-  const toggleCheckbox = useCallback(
-    (checked: boolean, index: number) => {
-      const selectedMembers = [...memberInvites];
-      selectedMembers[index]!.selected = checked;
-      setMemberInvites(selectedMembers);
-    },
-    [memberInvites]
-  );
+  const selectAll = (checked: boolean) => {
+    const selectedMembers = memberInvites.map(m => ({...m, selected: checked}));
+    setMemberInvites(selectedMembers);
+  };
+
+  const toggleCheckbox = (checked: boolean, index: number) => {
+    const selectedMembers = [...memberInvites];
+    selectedMembers[index]!.selected = checked;
+    setMemberInvites(selectedMembers);
+  };
 
   if (memberInvites.length === 0 || !organization.access.includes('org:write')) {
     return null;
diff --git a/static/app/components/modals/projectCreationModal.tsx b/static/app/components/modals/projectCreationModal.tsx
index e0f7faf25a1177..8111a29280fc63 100644
--- a/static/app/components/modals/projectCreationModal.tsx
+++ b/static/app/components/modals/projectCreationModal.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback, useState} from 'react';
+import {Fragment, useState} from 'react';
 import {css} from '@emotion/react';
 import styled from '@emotion/styled';
 import omit from 'lodash/omit';
@@ -15,14 +15,14 @@ import {
   clearIndicators,
 } from 'sentry/actionCreators/indicator';
 import {
+  type ModalRenderProps,
   openConsoleModal,
   openProjectCreationModal,
-  type ModalRenderProps,
 } from 'sentry/actionCreators/modal';
 import {
-  PlatformPicker,
   type Category,
   type Platform,
+  PlatformPicker,
 } from 'sentry/components/platformPicker';
 import type {TeamOption} from 'sentry/components/teamSelector';
 import {TeamSelector} from 'sentry/components/teamSelector';
@@ -94,7 +94,7 @@ export default function ProjectCreationModal({
     });
   }
 
-  const createProject = useCallback(async () => {
+  const createProject = async () => {
     const {slug} = organization;
 
     const alertRuleConfig = getRequestDataFragment(alertForm);
@@ -156,7 +156,7 @@ export default function ProjectCreationModal({
       setCreating(false);
       addErrorMessage(`Failed to create project ${projectName}`);
     }
-  }, [api, organization, platform, projectName, team, closeModal, alertForm]);
+  };
 
   return (
     <Fragment>
diff --git a/static/app/components/onboarding/productSelection.tsx b/static/app/components/onboarding/productSelection.tsx
index c678cce9a43667..79d5e4fc5e59d4 100644
--- a/static/app/components/onboarding/productSelection.tsx
+++ b/static/app/components/onboarding/productSelection.tsx
@@ -1,5 +1,5 @@
 import type {ReactNode} from 'react';
-import {useCallback, useEffect, useEffectEvent, useMemo} from 'react';
+import {useEffect, useEffectEvent, useMemo} from 'react';
 import styled from '@emotion/styled';
 
 import {Button} from '@sentry/scraps/button';
@@ -631,39 +631,36 @@ export function ProductSelection({
     initializeProducts();
   }, []);
 
-  const handleClickProduct = useCallback(
-    (product: ProductSolution) => {
-      const newProduct = new Set(
-        urlProducts.includes(product)
-          ? urlProducts.filter(p => p !== product)
-          : [...urlProducts, product]
-      );
+  const handleClickProduct = (product: ProductSolution) => {
+    const newProduct = new Set(
+      urlProducts.includes(product)
+        ? urlProducts.filter(p => p !== product)
+        : [...urlProducts, product]
+    );
 
-      if (products?.includes(ProductSolution.PROFILING)) {
-        // Ensure that if profiling is enabled, tracing is also enabled
-        if (
-          product === ProductSolution.PROFILING &&
-          newProduct.has(ProductSolution.PROFILING)
-        ) {
-          newProduct.add(ProductSolution.PERFORMANCE_MONITORING);
-        } else if (
-          product === ProductSolution.PERFORMANCE_MONITORING &&
-          !newProduct.has(ProductSolution.PERFORMANCE_MONITORING)
-        ) {
-          newProduct.delete(ProductSolution.PROFILING);
-        }
+    if (products?.includes(ProductSolution.PROFILING)) {
+      // Ensure that if profiling is enabled, tracing is also enabled
+      if (
+        product === ProductSolution.PROFILING &&
+        newProduct.has(ProductSolution.PROFILING)
+      ) {
+        newProduct.add(ProductSolution.PERFORMANCE_MONITORING);
+      } else if (
+        product === ProductSolution.PERFORMANCE_MONITORING &&
+        !newProduct.has(ProductSolution.PERFORMANCE_MONITORING)
+      ) {
+        newProduct.delete(ProductSolution.PROFILING);
       }
+    }
 
-      const selectedProducts = Array.from(newProduct);
+    const selectedProducts = Array.from(newProduct);
 
-      onChange?.({
-        previousProducts: urlProducts,
-        products: selectedProducts,
-      });
-      setParams({product: selectedProducts});
-    },
-    [products, setParams, urlProducts, onChange]
-  );
+    onChange?.({
+      previousProducts: urlProducts,
+      products: selectedProducts,
+    });
+    setParams({product: selectedProducts});
+  };
 
   if (!products) {
     // if the platform does not support any product, we don't render anything
diff --git a/static/app/components/onboardingWizard/content.tsx b/static/app/components/onboardingWizard/content.tsx
index 56aee9b89fb137..619236c8fb87e0 100644
--- a/static/app/components/onboardingWizard/content.tsx
+++ b/static/app/components/onboardingWizard/content.tsx
@@ -233,7 +233,7 @@ function Task({task, hidePanel}: TaskProps) {
     [task, organization, navigate, location, hidePanel, tours, sidebarTour]
   );
 
-  const handleMarkSkipped = useCallback(() => {
+  const handleMarkSkipped = () => {
     // all demos tasks are not skippable,
     // so this apply for the quick start only.
     // Adding this check here just in case it changes in the future
@@ -255,7 +255,7 @@ function Task({task, hidePanel}: TaskProps) {
         completionSeen: true,
       },
     ]);
-  }, [task, organization, mutateOnboardingTasks]);
+  };
 
   const iconTooltipText = useMemo(() => {
     switch (task.status) {
diff --git a/static/app/components/pageFilters/environment/environmentPageFilter.tsx b/static/app/components/pageFilters/environment/environmentPageFilter.tsx
index 8efd90901fc26b..7cbf1e07c2dc5e 100644
--- a/static/app/components/pageFilters/environment/environmentPageFilter.tsx
+++ b/static/app/components/pageFilters/environment/environmentPageFilter.tsx
@@ -225,11 +225,11 @@ export function EnvironmentPageFilter({
   const hasStagedChanges = xor(stagedSelect.value, value).length > 0;
   const shouldShowReset = stagedSelect.value.length > 0;
 
-  const handleReset = useCallback(() => {
+  const handleReset = () => {
     dispatch({type: 'remove staged'});
     handleChange([]);
     onReset?.();
-  }, [dispatch, handleChange, onReset]);
+  };
 
   return (
     <CompactSelect
diff --git a/static/app/components/profiling/continuousProfileHeader.tsx b/static/app/components/profiling/continuousProfileHeader.tsx
index 7b0ef4ac20ca16..22305a87fa26a3 100644
--- a/static/app/components/profiling/continuousProfileHeader.tsx
+++ b/static/app/components/profiling/continuousProfileHeader.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback, useMemo} from 'react';
+import {Fragment, useMemo} from 'react';
 import styled from '@emotion/styled';
 
 import {LinkButton} from '@sentry/scraps/button';
@@ -40,11 +40,11 @@ export function ContinuousProfileHeader({transaction}: ContinuousProfileHeader)
       })
     : null;
 
-  const handleGoToTransaction = useCallback(() => {
+  const handleGoToTransaction = () => {
     trackAnalytics('profiling_views.go_to_transaction', {
       organization,
     });
-  }, [organization]);
+  };
 
   return (
     <SmallerLayoutHeader>
diff --git a/static/app/components/profiling/flamegraph/flamegraphDrawer/flamegraphDrawer.tsx b/static/app/components/profiling/flamegraph/flamegraphDrawer/flamegraphDrawer.tsx
index 65f9cd9b8280da..97fcdb8caf6f32 100644
--- a/static/app/components/profiling/flamegraph/flamegraphDrawer/flamegraphDrawer.tsx
+++ b/static/app/components/profiling/flamegraph/flamegraphDrawer/flamegraphDrawer.tsx
@@ -78,12 +78,9 @@ const FlamegraphDrawer = memo(function FlamegraphDrawer(props: FlamegraphDrawerP
     return invertCallTree(maybeFilteredRoots);
   }, [tab, treeType, props.rootNodes]);
 
-  const handleRecursionChange = useCallback(
-    (evt: React.ChangeEvent<HTMLInputElement>) => {
-      setRecursion(evt.currentTarget.checked ? 'collapsed' : null);
-    },
-    []
-  );
+  const handleRecursionChange = (evt: React.ChangeEvent<HTMLInputElement>) => {
+    setRecursion(evt.currentTarget.checked ? 'collapsed' : null);
+  };
 
   const onBottomUpClick = useCallback(() => {
     setTab('bottom up');
@@ -93,17 +90,17 @@ const FlamegraphDrawer = memo(function FlamegraphDrawer(props: FlamegraphDrawerP
     setTab('top down');
   }, [setTab]);
 
-  const onAllApplicationsClick = useCallback(() => {
+  const onAllApplicationsClick = () => {
     setTreeType('all');
-  }, []);
+  };
 
-  const onApplicationsClick = useCallback(() => {
+  const onApplicationsClick = () => {
     setTreeType('application');
-  }, []);
+  };
 
-  const onSystemsClick = useCallback(() => {
+  const onSystemsClick = () => {
     setTreeType('system');
-  }, []);
+  };
 
   const onTableLeftClick = useCallback(() => {
     dispatch({type: 'set layout', payload: 'table left'});
diff --git a/static/app/components/profiling/flamegraph/flamegraphDrawer/flamegraphTreeTable.tsx b/static/app/components/profiling/flamegraph/flamegraphDrawer/flamegraphTreeTable.tsx
index a02ef7c301afa7..62ee0a882f5887 100644
--- a/static/app/components/profiling/flamegraph/flamegraphDrawer/flamegraphTreeTable.tsx
+++ b/static/app/components/profiling/flamegraph/flamegraphDrawer/flamegraphTreeTable.tsx
@@ -256,19 +256,16 @@ export function FlamegraphTreeTable({
     tree,
   });
 
-  const onSortChange = useCallback(
-    (newSort: 'total weight' | 'self weight' | 'name') => {
-      const newDirection =
-        newSort === sort ? (direction === 'asc' ? 'desc' : 'asc') : 'desc';
+  const onSortChange = (newSort: 'total weight' | 'self weight' | 'name') => {
+    const newDirection =
+      newSort === sort ? (direction === 'asc' ? 'desc' : 'asc') : 'desc';
 
-      setDirection(newDirection);
-      setSort(newSort);
+    setDirection(newDirection);
+    setSort(newSort);
 
-      const sortFn = makeCallTreeTableSortFunction(newSort, newDirection);
-      handleSortingChange(sortFn);
-    },
-    [sort, direction, handleSortingChange]
-  );
+    const sortFn = makeCallTreeTableSortFunction(newSort, newDirection);
+    handleSortingChange(sortFn);
+  };
 
   useEffect(() => {
     function onShowInTableView(frame: FlamegraphFrame) {
diff --git a/static/app/components/profiling/flamegraph/flamegraphDrawer/profileDetails.tsx b/static/app/components/profiling/flamegraph/flamegraphDrawer/profileDetails.tsx
index 70edbe4941b219..56f30f2d64aec9 100644
--- a/static/app/components/profiling/flamegraph/flamegraphDrawer/profileDetails.tsx
+++ b/static/app/components/profiling/flamegraph/flamegraphDrawer/profileDetails.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback, useMemo, useRef, useState} from 'react';
+import {Fragment, useMemo, useRef, useState} from 'react';
 import styled from '@emotion/styled';
 import {PlatformIcon} from 'platformicons';
 
@@ -67,13 +67,13 @@ export function ProfileDetails(props: ProfileDetailsProps) {
     p => p.id === String(props.profileGroup.metadata.projectID)
   );
 
-  const onEnvironmentTabClick = useCallback(() => {
+  const onEnvironmentTabClick = () => {
     setDetailsTab('environment');
-  }, []);
+  };
 
-  const onTransactionTabClick = useCallback(() => {
+  const onTransactionTabClick = () => {
     setDetailsTab('transaction');
-  }, []);
+  };
 
   const flamegraphPreferences = useFlamegraphPreferences();
   const isResizableDetailsBar =
diff --git a/static/app/components/profiling/flamegraph/flamegraphToolbar/differentialFlamegraphNegationSwitch.tsx b/static/app/components/profiling/flamegraph/flamegraphToolbar/differentialFlamegraphNegationSwitch.tsx
index b62ad7c19ff618..d35fde838c9f35 100644
--- a/static/app/components/profiling/flamegraph/flamegraphToolbar/differentialFlamegraphNegationSwitch.tsx
+++ b/static/app/components/profiling/flamegraph/flamegraphToolbar/differentialFlamegraphNegationSwitch.tsx
@@ -1,4 +1,3 @@
-import {useCallback} from 'react';
 import styled from '@emotion/styled';
 
 import {SegmentedControl} from '@sentry/scraps/segmentedControl';
@@ -13,12 +12,9 @@ export function DifferentialFlamegraphNegationSwitch(
   props: DifferentialFlamegraphNegationSwitchProps
 ) {
   const onNegatedChange = props.onNegatedChange;
-  const onWrapChange = useCallback(
-    (value: 'negated' | 'regular') => {
-      onNegatedChange(value === 'negated');
-    },
-    [onNegatedChange]
-  );
+  const onWrapChange = (value: 'negated' | 'regular') => {
+    onNegatedChange(value === 'negated');
+  };
 
   return (
     <DifferentialFlamegraphNegationSwitchContainer>
diff --git a/static/app/components/profiling/flamegraph/flamegraphToolbar/differentialFlamegraphSettingsButton.tsx b/static/app/components/profiling/flamegraph/flamegraphToolbar/differentialFlamegraphSettingsButton.tsx
index 422d1ab259fae6..47f045735a5b29 100644
--- a/static/app/components/profiling/flamegraph/flamegraphToolbar/differentialFlamegraphSettingsButton.tsx
+++ b/static/app/components/profiling/flamegraph/flamegraphToolbar/differentialFlamegraphSettingsButton.tsx
@@ -29,9 +29,9 @@ export function DifferentialFlamegraphSettingsButton(
 
   const contextMenu = useContextMenu({container: null});
 
-  const onToggleMenu = useCallback(() => {
+  const onToggleMenu = () => {
     contextMenu.setOpen(!contextMenu.open);
-  }, [contextMenu]);
+  };
 
   const onClose = useCallback(() => {
     contextMenu.setOpen(false);
diff --git a/static/app/components/profiling/flamegraph/flamegraphToolbar/differentialFlamegraphToolbar.tsx b/static/app/components/profiling/flamegraph/flamegraphToolbar/differentialFlamegraphToolbar.tsx
index 2baf4d9ea07821..c0d788d2092f75 100644
--- a/static/app/components/profiling/flamegraph/flamegraphToolbar/differentialFlamegraphToolbar.tsx
+++ b/static/app/components/profiling/flamegraph/flamegraphToolbar/differentialFlamegraphToolbar.tsx
@@ -1,4 +1,3 @@
-import {useCallback} from 'react';
 import styled from '@emotion/styled';
 
 import {Button} from '@sentry/scraps/button';
@@ -22,9 +21,9 @@ interface DifferentialFlamegraphProps {
   onNegatedChange: (source: boolean) => void;
 }
 export function DifferentialFlamegraphToolbar(props: DifferentialFlamegraphProps) {
-  const onResetZoom = useCallback(() => {
+  const onResetZoom = () => {
     props.canvasPoolManager.dispatch('reset zoom', []);
-  }, [props.canvasPoolManager]);
+  };
 
   return (
     <DifferentialFlamegraphToolbarContainer>
diff --git a/static/app/components/profiling/flamegraph/flamegraphToolbar/flamegraphOptionsMenu.tsx b/static/app/components/profiling/flamegraph/flamegraphToolbar/flamegraphOptionsMenu.tsx
index 918e54c035140b..9a5b59be299ecf 100644
--- a/static/app/components/profiling/flamegraph/flamegraphToolbar/flamegraphOptionsMenu.tsx
+++ b/static/app/components/profiling/flamegraph/flamegraphToolbar/flamegraphOptionsMenu.tsx
@@ -39,13 +39,13 @@ function FlamegraphOptionsMenu({
     [dispatch]
   );
 
-  const onResetZoom = useCallback(() => {
+  const onResetZoom = () => {
     canvasPoolManager.dispatch('reset zoom', []);
     trackAnalytics('profiling_views.flamegraph.zoom.reset', {
       organization,
       profile_type: profileType,
     });
-  }, [canvasPoolManager, organization, profileType]);
+  };
 
   const continuousLocationDescriptor = useMemo(
     () => {
diff --git a/static/app/components/profiling/profileHeader.tsx b/static/app/components/profiling/profileHeader.tsx
index bd412bf6c5e3f1..8de4f4cc618e63 100644
--- a/static/app/components/profiling/profileHeader.tsx
+++ b/static/app/components/profiling/profileHeader.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback, useMemo} from 'react';
+import {Fragment, useMemo} from 'react';
 import styled from '@emotion/styled';
 
 import {LinkButton} from '@sentry/scraps/button';
@@ -55,11 +55,11 @@ function ProfileHeader({transaction, projectId, eventId}: ProfileHeaderProps) {
       })
     : null;
 
-  const handleGoToTransaction = useCallback(() => {
+  const handleGoToTransaction = () => {
     trackAnalytics('profiling_views.go_to_transaction', {
       organization,
     });
-  }, [organization]);
+  };
 
   const breadcrumbTrails = useMemo(() => {
     return [
diff --git a/static/app/components/projects/missingProjectMembership.tsx b/static/app/components/projects/missingProjectMembership.tsx
index 239815dbfb1c15..7c3957af5fd0a1 100644
--- a/static/app/components/projects/missingProjectMembership.tsx
+++ b/static/app/components/projects/missingProjectMembership.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useMemo, useState} from 'react';
+import {useMemo, useState} from 'react';
 import styled from '@emotion/styled';
 
 import {Button} from '@sentry/scraps/button';
@@ -29,7 +29,7 @@ function JoinTeamAction({teamSlug, organization}: JoinTeamActionProps) {
   const teamStoreData = useLegacyStore(TeamStore);
   const selectedTeam = teamStoreData.teams.find(team => team.slug === teamSlug);
 
-  const handleJoinTeam = useCallback(() => {
+  const handleJoinTeam = () => {
     setIsLoading(true);
 
     joinTeam(
@@ -49,7 +49,7 @@ function JoinTeamAction({teamSlug, organization}: JoinTeamActionProps) {
         },
       }
     );
-  }, [api, organization.slug, teamSlug]);
+  };
 
   const openMembership = organization.features.includes('open-membership');
 
diff --git a/static/app/components/replays/breadcrumbs/breadcrumbIssueLink.tsx b/static/app/components/replays/breadcrumbs/breadcrumbIssueLink.tsx
index 225f1af5496bd2..3d5acc5dd4cad5 100644
--- a/static/app/components/replays/breadcrumbs/breadcrumbIssueLink.tsx
+++ b/static/app/components/replays/breadcrumbs/breadcrumbIssueLink.tsx
@@ -1,4 +1,4 @@
-import {useCallback, type MouseEvent} from 'react';
+import {type MouseEvent} from 'react';
 import styled from '@emotion/styled';
 
 import {ProjectAvatar} from '@sentry/scraps/avatar';
@@ -27,9 +27,9 @@ function CrumbErrorIssue({frame}: {frame: FeedbackFrame | ErrorFrame}) {
   const organization = useOrganization();
   const project = useProjectFromSlug({organization, projectSlug: frame.data.projectSlug});
   const {groupId} = useReplayGroupContext();
-  const handleClick = useCallback((e: MouseEvent<HTMLAnchorElement>) => {
+  const handleClick = (e: MouseEvent<HTMLAnchorElement>) => {
     e.stopPropagation();
-  }, []);
+  };
 
   const projectAvatar = project ? <ProjectAvatar project={project} size={16} /> : null;
 
diff --git a/static/app/components/replays/breadcrumbs/errorTitle.tsx b/static/app/components/replays/breadcrumbs/errorTitle.tsx
index 0ca0a17c824403..ae8327ce9f49b1 100644
--- a/static/app/components/replays/breadcrumbs/errorTitle.tsx
+++ b/static/app/components/replays/breadcrumbs/errorTitle.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback, type MouseEvent} from 'react';
+import {Fragment, type MouseEvent} from 'react';
 import capitalize from 'lodash/capitalize';
 
 import {Link} from '@sentry/scraps/link';
@@ -11,9 +11,9 @@ import {useOrganization} from 'sentry/utils/useOrganization';
 export function CrumbErrorTitle({frame}: {frame: ErrorFrame}) {
   const organization = useOrganization();
   const {eventId} = useReplayGroupContext();
-  const handleClick = useCallback((e: MouseEvent<HTMLAnchorElement>) => {
+  const handleClick = (e: MouseEvent<HTMLAnchorElement>) => {
     e.stopPropagation();
-  }, []);
+  };
 
   if (eventId === frame.data.eventId) {
     return <Fragment>Error: This Event</Fragment>;
diff --git a/static/app/components/replays/replayFullscreenButton.tsx b/static/app/components/replays/replayFullscreenButton.tsx
index aef818da0f71f8..bf1d029f3d272a 100644
--- a/static/app/components/replays/replayFullscreenButton.tsx
+++ b/static/app/components/replays/replayFullscreenButton.tsx
@@ -1,4 +1,3 @@
-import {useCallback} from 'react';
 import screenfull from 'screenfull';
 
 import {Button} from '@sentry/scraps/button';
@@ -21,7 +20,7 @@ export function ReplayFullscreenButton({toggleFullscreen}: Props) {
   const isFullscreen = useIsFullscreen();
   const {analyticsContext} = useReplayContext();
 
-  const handleFullscreenToggle = useCallback(() => {
+  const handleFullscreenToggle = () => {
     trackAnalytics('replay.toggle-fullscreen', {
       organization,
       context: analyticsContext,
@@ -29,7 +28,7 @@ export function ReplayFullscreenButton({toggleFullscreen}: Props) {
       fullscreen: !isFullscreen,
     });
     toggleFullscreen();
-  }, [analyticsContext, isFullscreen, organization, toggleFullscreen, user.email]);
+  };
 
   // If the browser supports going fullscreen or not. iPhone Safari won't do
   // it. https://caniuse.com/fullscreen
diff --git a/static/app/components/replays/table/deleteReplays.tsx b/static/app/components/replays/table/deleteReplays.tsx
index 4d00ed547ff87f..f7dc5669d88fd2 100644
--- a/static/app/components/replays/table/deleteReplays.tsx
+++ b/static/app/components/replays/table/deleteReplays.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback} from 'react';
+import {Fragment} from 'react';
 import styled from '@emotion/styled';
 import invariant from 'invariant';
 
@@ -22,11 +22,11 @@ import {IconCalendar, IconDelete} from 'sentry/icons';
 import {t, tct, tn} from 'sentry/locale';
 import type {Project} from 'sentry/types/project';
 import {getShortEventId} from 'sentry/utils/events';
-import {useQueryClient, type QueryKeyEndpointOptions} from 'sentry/utils/queryClient';
+import {type QueryKeyEndpointOptions, useQueryClient} from 'sentry/utils/queryClient';
 import {decodeList} from 'sentry/utils/queryString';
 import {
-  useDeleteReplays,
   type ReplayBulkDeletePayload,
+  useDeleteReplays,
 } from 'sentry/utils/replays/hooks/useDeleteReplays';
 import {useLocationQuery} from 'sentry/utils/url/useLocationQuery';
 import {useOrganization} from 'sentry/utils/useOrganization';
@@ -79,9 +79,9 @@ export function DeleteReplays({selectedIds, replays, queryOptions}: Props) {
     projectSlug: project?.slug ?? '',
     query: {referrer: analyticsArea},
   });
-  const refetchAuditLog = useCallback(() => {
+  const refetchAuditLog = () => {
     queryClient.invalidateQueries({queryKey});
-  }, [queryClient, queryKey]);
+  };
 
   return (
     <Tooltip
diff --git a/static/app/components/replays/timeAndScrubberGrid.tsx b/static/app/components/replays/timeAndScrubberGrid.tsx
index 0b5b267d488e5b..3c0099774bc286 100644
--- a/static/app/components/replays/timeAndScrubberGrid.tsx
+++ b/static/app/components/replays/timeAndScrubberGrid.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useRef} from 'react';
+import {useRef} from 'react';
 import {css} from '@emotion/react';
 import styled from '@emotion/styled';
 
@@ -33,21 +33,21 @@ function TimelineSizeBar({isLoading}: {isLoading?: boolean}) {
   const durationMs = replay?.getDurationMs();
   const maxScale = durationMs ? Math.ceil(durationMs / 60000) : 10;
 
-  const handleZoomOut = useCallback(() => {
+  const handleZoomOut = () => {
     const newScale = Math.max(timelineScale - 1, 1);
     setTimelineScale(newScale);
     trackAnalytics('replay.timeline.zoom-out', {
       organization,
     });
-  }, [timelineScale, setTimelineScale, organization]);
+  };
 
-  const handleZoomIn = useCallback(() => {
+  const handleZoomIn = () => {
     const newScale = Math.min(timelineScale + 1, maxScale);
     setTimelineScale(newScale);
     trackAnalytics('replay.timeline.zoom-in', {
       organization,
     });
-  }, [timelineScale, maxScale, setTimelineScale, organization]);
+  };
 
   return (
     <Grid flow="column" align="center" gap="0">
diff --git a/static/app/components/searchQueryBuilder/selectionKeyHandler.tsx b/static/app/components/searchQueryBuilder/selectionKeyHandler.tsx
index 568fe91e036124..89d24b09f2ab38 100644
--- a/static/app/components/searchQueryBuilder/selectionKeyHandler.tsx
+++ b/static/app/components/searchQueryBuilder/selectionKeyHandler.tsx
@@ -1,4 +1,3 @@
-import {useCallback} from 'react';
 import {VisuallyHidden} from '@react-aria/visually-hidden';
 import type {ListState} from '@react-stately/list';
 
@@ -38,152 +37,143 @@ export function SelectionKeyHandler({
     .map(key => state.collection.getItem(key)?.value)
     .filter(defined);
 
-  const onPaste = useCallback(
-    (e: React.ClipboardEvent<HTMLInputElement>) => {
-      e.preventDefault();
-      e.stopPropagation();
-
-      const text = e.clipboardData.getData('text/plain').replace('\n', '').trim();
-
-      dispatch({
-        type: 'REPLACE_TOKENS_WITH_TEXT_ON_PASTE',
-        tokens: selectedTokens,
-        text,
-      });
-    },
-    [dispatch, selectedTokens]
-  );
-
-  const onKeyDown = useCallback(
-    (e: React.KeyboardEvent<HTMLDivElement>) => {
-      switch (e.key) {
-        case 'Backspace':
-        case 'Delete': {
-          e.preventDefault();
-          e.stopPropagation();
-          dispatch({
-            type: 'REPLACE_TOKENS_WITH_TEXT_ON_DELETE',
-            tokens: selectedTokens,
-            text: '',
-          });
-          state.selectionManager.setFocusedKey(
-            findNearestFreeTextKey(state, state.selectionManager.firstSelectedKey, 'left')
-          );
-          state.selectionManager.clearSelection();
-
-          // Ask Seer - Clear the input value when the user deletes all tokens
-          if (state.collection.size === selectedTokens.length) {
-            currentInputValueRef.current = '';
-          }
-          return;
+  const onPaste = (e: React.ClipboardEvent<HTMLInputElement>) => {
+    e.preventDefault();
+    e.stopPropagation();
+
+    const text = e.clipboardData.getData('text/plain').replace('\n', '').trim();
+
+    dispatch({
+      type: 'REPLACE_TOKENS_WITH_TEXT_ON_PASTE',
+      tokens: selectedTokens,
+      text,
+    });
+  };
+
+  const onKeyDown = (e: React.KeyboardEvent<HTMLDivElement>) => {
+    switch (e.key) {
+      case 'Backspace':
+      case 'Delete': {
+        e.preventDefault();
+        e.stopPropagation();
+        dispatch({
+          type: 'REPLACE_TOKENS_WITH_TEXT_ON_DELETE',
+          tokens: selectedTokens,
+          text: '',
+        });
+        state.selectionManager.setFocusedKey(
+          findNearestFreeTextKey(state, state.selectionManager.firstSelectedKey, 'left')
+        );
+        state.selectionManager.clearSelection();
+
+        // Ask Seer - Clear the input value when the user deletes all tokens
+        if (state.collection.size === selectedTokens.length) {
+          currentInputValueRef.current = '';
         }
-        case 'ArrowRight':
-          e.preventDefault();
-          e.stopPropagation();
-
-          if (e.shiftKey) {
-            selectInDirection({state, direction: 'right'});
-            return;
-          }
+        return;
+      }
+      case 'ArrowRight':
+        e.preventDefault();
+        e.stopPropagation();
 
-          state.selectionManager.clearSelection();
-          state.selectionManager.setFocusedKey(
-            findNearestFreeTextKey(state, state.selectionManager.lastSelectedKey, 'right')
-          );
+        if (e.shiftKey) {
+          selectInDirection({state, direction: 'right'});
           return;
-        case 'ArrowLeft':
-          e.preventDefault();
-          e.stopPropagation();
+        }
 
-          if (e.shiftKey) {
-            selectInDirection({state, direction: 'left'});
-            return;
-          }
+        state.selectionManager.clearSelection();
+        state.selectionManager.setFocusedKey(
+          findNearestFreeTextKey(state, state.selectionManager.lastSelectedKey, 'right')
+        );
+        return;
+      case 'ArrowLeft':
+        e.preventDefault();
+        e.stopPropagation();
 
-          state.selectionManager.clearSelection();
-          state.selectionManager.setFocusedKey(
-            findNearestFreeTextKey(state, state.selectionManager.firstSelectedKey, 'left')
-          );
+        if (e.shiftKey) {
+          selectInDirection({state, direction: 'left'});
           return;
-        default:
-          if (isCtrlKeyPressed(e)) {
-            const copySelectedTokens = () => {
-              const queryToCopy = selectedTokens
-                .map(token => token.text)
-                .join('')
-                .trim();
-              navigator.clipboard.writeText(queryToCopy);
-            };
-
-            if (e.key === 'a') {
-              state.selectionManager.selectAll();
-              e.preventDefault();
-              e.stopPropagation();
-            } else if (e.key === 'z') {
-              state.selectionManager.clearSelection();
-              undo();
-              e.stopPropagation();
-              e.preventDefault();
-            } else if (e.key === 'x') {
-              state.selectionManager.clearSelection();
-              copySelectedTokens();
-              dispatch({
-                type: 'REPLACE_TOKENS_WITH_TEXT_ON_CUT',
-                tokens: selectedTokens,
-                text: '',
-              });
-              e.stopPropagation();
-              e.preventDefault();
-            } else if (e.key === 'c') {
-              copySelectedTokens();
-              e.preventDefault();
-              e.stopPropagation();
-            }
-            return;
-          }
+        }
 
-          // Wrap selected tokens in parentheses when ( or ) is pressed
-          if ((e.key === '(' || e.key === ')') && selectedTokens.length > 0) {
+        state.selectionManager.clearSelection();
+        state.selectionManager.setFocusedKey(
+          findNearestFreeTextKey(state, state.selectionManager.firstSelectedKey, 'left')
+        );
+        return;
+      default:
+        if (isCtrlKeyPressed(e)) {
+          const copySelectedTokens = () => {
+            const queryToCopy = selectedTokens
+              .map(token => token.text)
+              .join('')
+              .trim();
+            navigator.clipboard.writeText(queryToCopy);
+          };
+
+          if (e.key === 'a') {
+            state.selectionManager.selectAll();
             e.preventDefault();
             e.stopPropagation();
-            dispatch({
-              type: 'WRAP_TOKENS_WITH_PARENTHESES',
-              tokens: selectedTokens,
-            });
+          } else if (e.key === 'z') {
             state.selectionManager.clearSelection();
-            return;
-          }
-
-          // If the key pressed will generate a symbol, replace the selection with it
-          if (/^.$/u.test(e.key)) {
+            undo();
+            e.stopPropagation();
+            e.preventDefault();
+          } else if (e.key === 'x') {
+            state.selectionManager.clearSelection();
+            copySelectedTokens();
             dispatch({
-              type: 'REPLACE_TOKENS_WITH_TEXT_ON_KEY_DOWN',
-              text: e.key,
+              type: 'REPLACE_TOKENS_WITH_TEXT_ON_CUT',
               tokens: selectedTokens,
+              text: '',
             });
-            state.selectionManager.clearSelection();
+            e.stopPropagation();
+            e.preventDefault();
+          } else if (e.key === 'c') {
+            copySelectedTokens();
             e.preventDefault();
             e.stopPropagation();
           }
+          return;
+        }
 
+        // Wrap selected tokens in parentheses when ( or ) is pressed
+        if ((e.key === '(' || e.key === ')') && selectedTokens.length > 0) {
+          e.preventDefault();
+          e.stopPropagation();
+          dispatch({
+            type: 'WRAP_TOKENS_WITH_PARENTHESES',
+            tokens: selectedTokens,
+          });
+          state.selectionManager.clearSelection();
           return;
-      }
-    },
-    [currentInputValueRef, dispatch, selectInDirection, selectedTokens, state, undo]
-  );
+        }
+
+        // If the key pressed will generate a symbol, replace the selection with it
+        if (/^.$/u.test(e.key)) {
+          dispatch({
+            type: 'REPLACE_TOKENS_WITH_TEXT_ON_KEY_DOWN',
+            text: e.key,
+            tokens: selectedTokens,
+          });
+          state.selectionManager.clearSelection();
+          e.preventDefault();
+          e.stopPropagation();
+        }
 
-  // Ensure that the selection is cleared when this input loses focus
-  const onBlur = useCallback(
-    (e: React.FocusEvent<HTMLInputElement>) => {
-      // React Aria will sometimes focus the grid element, which we handle in useQueryBuilderGrid().
-      // This should be ignored since focus will return here.
-      if (e.relatedTarget === gridRef.current) {
         return;
-      }
-      state.selectionManager.clearSelection();
-    },
-    [state.selectionManager, gridRef]
-  );
+    }
+  };
+
+  // Ensure that the selection is cleared when this input loses focus
+  const onBlur = (e: React.FocusEvent<HTMLInputElement>) => {
+    // React Aria will sometimes focus the grid element, which we handle in useQueryBuilderGrid().
+    // This should be ignored since focus will return here.
+    if (e.relatedTarget === gridRef.current) {
+      return;
+    }
+    state.selectionManager.clearSelection();
+  };
 
   // Using VisuallyHidden because display: none will not allow the input to be focused
   return (
diff --git a/static/app/components/stackTrace/exceptionGroup.tsx b/static/app/components/stackTrace/exceptionGroup.tsx
index 49c0af15046efc..518a08963d8ab5 100644
--- a/static/app/components/stackTrace/exceptionGroup.tsx
+++ b/static/app/components/stackTrace/exceptionGroup.tsx
@@ -29,14 +29,14 @@ export function useHiddenExceptions(values: ExceptionValue[]) {
       )
   );
 
-  const toggleRelatedExceptions = useCallback((exceptionId: number) => {
+  const toggleRelatedExceptions = (exceptionId: number) => {
     setHiddenExceptions(old => {
       if (!defined(old[exceptionId])) {
         return old;
       }
       return {...old, [exceptionId]: !old[exceptionId]};
     });
-  }, []);
+  };
 
   const expandException = useCallback(
     (exceptionId: number) => {
diff --git a/static/app/components/timeRangeSelector/index.tsx b/static/app/components/timeRangeSelector/index.tsx
index 88eceb32d1a9e8..097f23c699ad51 100644
--- a/static/app/components/timeRangeSelector/index.tsx
+++ b/static/app/components/timeRangeSelector/index.tsx
@@ -270,34 +270,31 @@ export function TimeRangeSelector({
     );
   }, [showRelative, onChange, internalValue, hasChanges]);
 
-  const handleChange = useCallback(
-    (option: SelectOption<string>) => {
-      // The absolute option was selected -> open absolute selector
-      if (option.value === ABSOLUTE_OPTION_VALUE) {
-        setInternalValue(current => {
-          const defaultStart = defaultAbsolute?.start
-            ? defaultAbsolute.start
-            : getPeriodAgo(
-                'hours',
-                parsePeriodToHours(relative || defaultPeriod || DEFAULT_STATS_PERIOD)
-              ).toDate();
-          const defaultEnd = defaultAbsolute?.end ? defaultAbsolute.end : new Date();
-          return {
-            ...current,
-            // Update default values for absolute selector
-            start: start ? getInternalDate(start, utc) : defaultStart,
-            end: end ? getInternalDate(end, utc) : defaultEnd,
-          };
-        });
-        setShowAbsoluteSelector(true);
-        return;
-      }
+  const handleChange = (option: SelectOption<string>) => {
+    // The absolute option was selected -> open absolute selector
+    if (option.value === ABSOLUTE_OPTION_VALUE) {
+      setInternalValue(current => {
+        const defaultStart = defaultAbsolute?.start
+          ? defaultAbsolute.start
+          : getPeriodAgo(
+              'hours',
+              parsePeriodToHours(relative || defaultPeriod || DEFAULT_STATS_PERIOD)
+            ).toDate();
+        const defaultEnd = defaultAbsolute?.end ? defaultAbsolute.end : new Date();
+        return {
+          ...current,
+          // Update default values for absolute selector
+          start: start ? getInternalDate(start, utc) : defaultStart,
+          end: end ? getInternalDate(end, utc) : defaultEnd,
+        };
+      });
+      setShowAbsoluteSelector(true);
+      return;
+    }
 
-      setInternalValue(current => ({...current, relative: option.value}));
-      onChange?.({relative: option.value, start: undefined, end: undefined});
-    },
-    [start, end, utc, defaultAbsolute, defaultPeriod, relative, onChange]
-  );
+    setInternalValue(current => ({...current, relative: option.value}));
+    onChange?.({relative: option.value, start: undefined, end: undefined});
+  };
 
   const arbitraryRelativePeriods = getArbitraryRelativePeriod(relative);
 
diff --git a/static/app/components/webAuthn/webAuthnEnroll.tsx b/static/app/components/webAuthn/webAuthnEnroll.tsx
index 182082f7e3d6fc..d856b40b204472 100644
--- a/static/app/components/webAuthn/webAuthnEnroll.tsx
+++ b/static/app/components/webAuthn/webAuthnEnroll.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useState} from 'react';
+import {useState} from 'react';
 import styled from '@emotion/styled';
 
 import {Button} from '@sentry/scraps/button';
@@ -26,29 +26,26 @@ export function WebAuthnEnroll({challengeData}: WebAuthnEnrollProps) {
 
   const [activated, setActivated] = useState(false);
 
-  const triggerEnroll = useCallback(
-    async (model: FormModel) => {
-      setActivated(false);
-      model.setError('challenge', false);
-
-      try {
-        const webAuthnResponse = await handleEnroll(challengeData);
+  const triggerEnroll = async (model: FormModel) => {
+    setActivated(false);
+    model.setError('challenge', false);
 
-        if (!webAuthnResponse) {
-          model.setError('challenge', FAILURE_MESSAGE);
-          return;
-        }
+    try {
+      const webAuthnResponse = await handleEnroll(challengeData);
 
-        setActivated(true);
-        model.setValue('response', webAuthnResponse);
-        model.setValue('challenge', challenge);
-      } catch (err) {
+      if (!webAuthnResponse) {
         model.setError('challenge', FAILURE_MESSAGE);
-        setActivated(false);
+        return;
       }
-    },
-    [challenge, challengeData]
-  );
+
+      setActivated(true);
+      model.setValue('response', webAuthnResponse);
+      model.setValue('challenge', challenge);
+    } catch (err) {
+      model.setError('challenge', FAILURE_MESSAGE);
+      setActivated(false);
+    }
+  };
 
   return (
     <FormField
diff --git a/static/app/debug/notifications/components/debugNotificationsHeader.tsx b/static/app/debug/notifications/components/debugNotificationsHeader.tsx
index 3808f064b98a1d..68bc6e7c2eefff 100644
--- a/static/app/debug/notifications/components/debugNotificationsHeader.tsx
+++ b/static/app/debug/notifications/components/debugNotificationsHeader.tsx
@@ -1,4 +1,3 @@
-import {useCallback} from 'react';
 import styled from '@emotion/styled';
 
 import {Button, LinkButton} from '@sentry/scraps/button';
@@ -78,9 +77,9 @@ function ThemeSwitcher() {
   const config = useLegacyStore(ConfigStore);
   const isDark = config.theme === 'dark';
 
-  const handleClick = useCallback(() => {
+  const handleClick = () => {
     ConfigStore.set('theme', isDark ? 'light' : 'dark');
-  }, [isDark]);
+  };
 
   return (
     <Button
diff --git a/static/app/stories/theme.tsx b/static/app/stories/theme.tsx
index d2dd1d7ee9758c..f816fe7e5f5c3d 100644
--- a/static/app/stories/theme.tsx
+++ b/static/app/stories/theme.tsx
@@ -1,5 +1,3 @@
-import {useCallback} from 'react';
-
 import {Button} from '@sentry/scraps/button';
 
 import {IconMoon} from 'sentry/icons';
@@ -11,9 +9,9 @@ export function ThemeSwitcher() {
   const config = useLegacyStore(ConfigStore);
   const isDark = config.theme === 'dark';
 
-  const handleClick = useCallback(() => {
+  const handleClick = () => {
     ConfigStore.set('theme', isDark ? 'light' : 'dark');
-  }, [isDark]);
+  };
 
   return (
     <Button
diff --git a/static/app/utils/performance/contexts/onDemandControl.tsx b/static/app/utils/performance/contexts/onDemandControl.tsx
index 3ad3268054679f..cea63828aa7fbe 100644
--- a/static/app/utils/performance/contexts/onDemandControl.tsx
+++ b/static/app/utils/performance/contexts/onDemandControl.tsx
@@ -144,9 +144,9 @@ export function ToggleOnDemand() {
   const org = useOrganization();
   const onDemand = _useOnDemandControl();
 
-  const toggle = useCallback(() => {
+  const toggle = () => {
     onDemand.setForceOnDemand(!onDemand.forceOnDemand);
-  }, [onDemand]);
+  };
 
   if (!onDemand) {
     return null;
diff --git a/static/app/views/admin/adminRelays.tsx b/static/app/views/admin/adminRelays.tsx
index 7d238d25818cec..a7f20814cae539 100644
--- a/static/app/views/admin/adminRelays.tsx
+++ b/static/app/views/admin/adminRelays.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useState} from 'react';
+import {useState} from 'react';
 import moment from 'moment-timezone';
 
 import {Button} from '@sentry/scraps/button';
@@ -24,17 +24,14 @@ export default function AdminRelays() {
   // TODO: Loading not hooked up to anything?
   const [, setLoading] = useState(false);
 
-  const onDelete = useCallback(
-    (key: string) => {
-      setLoading(true);
-      api.request(`/relays/${key}/`, {
-        method: 'DELETE',
-        success: () => setLoading(false),
-        error: () => setLoading(false),
-      });
-    },
-    [api]
-  );
+  const onDelete = (key: string) => {
+    setLoading(true);
+    api.request(`/relays/${key}/`, {
+      method: 'DELETE',
+      success: () => setLoading(false),
+      error: () => setLoading(false),
+    });
+  };
 
   const getRow = (row: RelayRow) => {
     return [
diff --git a/static/app/views/alerts/rules/metric/details/anomalyDetectionFeedbackBanner.tsx b/static/app/views/alerts/rules/metric/details/anomalyDetectionFeedbackBanner.tsx
index 43f9d42b0f6006..006aa8c9bd70b1 100644
--- a/static/app/views/alerts/rules/metric/details/anomalyDetectionFeedbackBanner.tsx
+++ b/static/app/views/alerts/rules/metric/details/anomalyDetectionFeedbackBanner.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback} from 'react';
+import {Fragment} from 'react';
 
 import {Alert} from '@sentry/scraps/alert';
 import {Button} from '@sentry/scraps/button';
@@ -26,54 +26,41 @@ export function AnomalyDetectionFeedbackBanner({
   const [isSubmitted, submit] = useDismissable(id);
   const openFeedbackForm = useFeedbackForm();
 
-  const handleClick = useCallback(
-    (anomalyCorrectlyIdentified: boolean) => {
-      trackAnalytics('anomaly-detection.feedback-submitted', {
+  const handleClick = (anomalyCorrectlyIdentified: boolean) => {
+    trackAnalytics('anomaly-detection.feedback-submitted', {
+      choice_selected: anomalyCorrectlyIdentified,
+      organization,
+      incident_id: id,
+    });
+    feedbackClient.captureEvent({
+      request: {
+        url: window.location.href, // gives the full url (origin + pathname)
+      },
+      tags: {
+        featureName: 'anomaly-detection-alerts-feedback',
         choice_selected: anomalyCorrectlyIdentified,
-        organization,
         incident_id: id,
-      });
-      feedbackClient.captureEvent({
-        request: {
-          url: window.location.href, // gives the full url (origin + pathname)
-        },
+        alert_rule_id: selectedIncident.alertRule.id,
+        metric: selectedIncident.alertRule.query,
+        sensitivity: selectedIncident.alertRule.sensitivity,
+        direction: selectedIncident.alertRule.thresholdType,
+        time_window: selectedIncident.alertRule.timeWindow,
+      },
+      user: ConfigStore.get('user'),
+      level: 'info',
+      message: 'Anomaly Detection Alerts Banner Feedback',
+    });
+    if (!anomalyCorrectlyIdentified && openFeedbackForm) {
+      openFeedbackForm({
+        messagePlaceholder: t('Why was this anomaly incorrect?'),
         tags: {
-          featureName: 'anomaly-detection-alerts-feedback',
-          choice_selected: anomalyCorrectlyIdentified,
-          incident_id: id,
-          alert_rule_id: selectedIncident.alertRule.id,
-          metric: selectedIncident.alertRule.query,
-          sensitivity: selectedIncident.alertRule.sensitivity,
-          direction: selectedIncident.alertRule.thresholdType,
-          time_window: selectedIncident.alertRule.timeWindow,
+          ['feedback.source']: 'anomaly_detection_false_positive',
+          ['feedback.owner']: 'ml-ai',
         },
-        user: ConfigStore.get('user'),
-        level: 'info',
-        message: 'Anomaly Detection Alerts Banner Feedback',
       });
-      if (!anomalyCorrectlyIdentified && openFeedbackForm) {
-        openFeedbackForm({
-          messagePlaceholder: t('Why was this anomaly incorrect?'),
-          tags: {
-            ['feedback.source']: 'anomaly_detection_false_positive',
-            ['feedback.owner']: 'ml-ai',
-          },
-        });
-      }
-      submit();
-    },
-    [
-      id,
-      organization,
-      selectedIncident.alertRule.id,
-      selectedIncident.alertRule.query,
-      selectedIncident.alertRule.sensitivity,
-      selectedIncident.alertRule.thresholdType,
-      selectedIncident.alertRule.timeWindow,
-      submit,
-      openFeedbackForm,
-    ]
-  );
+    }
+    submit();
+  };
 
   if (isSubmitted) {
     return null;
diff --git a/static/app/views/alerts/rules/metric/eapField.tsx b/static/app/views/alerts/rules/metric/eapField.tsx
index e54e0d2112be29..f32b7d10614d81 100644
--- a/static/app/views/alerts/rules/metric/eapField.tsx
+++ b/static/app/views/alerts/rules/metric/eapField.tsx
@@ -161,19 +161,16 @@ export function EAPField({aggregate, onChange, eventTypes, project}: Props) {
     [aggregation, fieldsArray, traceItemType]
   );
 
-  const handleArgumentChange = useCallback(
-    (index: number, value: string) => {
-      let args = cloneDeep(aggregateFuncArgs);
-      if (args) {
-        args[index] = value;
-      } else {
-        args = [value];
-      }
-      const newYAxis = `${aggregation}(${args.join(',')})`;
-      onChange(newYAxis, {});
-    },
-    [aggregateFuncArgs, aggregation, onChange]
-  );
+  const handleArgumentChange = (index: number, value: string) => {
+    let args = cloneDeep(aggregateFuncArgs);
+    if (args) {
+      args[index] = value;
+    } else {
+      args = [value];
+    }
+    const newYAxis = `${aggregation}(${args.join(',')})`;
+    onChange(newYAxis, {});
+  };
 
   const handleOperationChange = useCallback(
     (option: any) => {
diff --git a/static/app/views/alerts/rules/metric/eapMetricsField.tsx b/static/app/views/alerts/rules/metric/eapMetricsField.tsx
index 453c90c8b44deb..adef040df974ba 100644
--- a/static/app/views/alerts/rules/metric/eapMetricsField.tsx
+++ b/static/app/views/alerts/rules/metric/eapMetricsField.tsx
@@ -162,27 +162,24 @@ export function EAPMetricsField({
     [onChange, traceMetric]
   );
 
-  const handleMetricChange = useCallback(
-    (option: MetricSelectOption) => {
-      const newMetric: TraceMetric = {
-        name: option.metricName,
-        type: option.metricType,
-        unit: hasMetricUnitsUI ? (option.metricUnit ?? NONE_UNIT) : undefined,
-      };
-      const newMetricType = option.metricType?.toLowerCase() ?? '';
-      const validOperations = OPTIONS_BY_TYPE[newMetricType] ?? [];
-
-      // Always reset to first available operation for the new metric type
-      const newAggregation = validOperations[0]?.value ?? 'avg';
-
-      const newAggregate = makeMetricsAggregate({
-        aggregate: newAggregation,
-        traceMetric: newMetric,
-      });
-      onChange(newAggregate, {});
-    },
-    [onChange, hasMetricUnitsUI]
-  );
+  const handleMetricChange = (option: MetricSelectOption) => {
+    const newMetric: TraceMetric = {
+      name: option.metricName,
+      type: option.metricType,
+      unit: hasMetricUnitsUI ? (option.metricUnit ?? NONE_UNIT) : undefined,
+    };
+    const newMetricType = option.metricType?.toLowerCase() ?? '';
+    const validOperations = OPTIONS_BY_TYPE[newMetricType] ?? [];
+
+    // Always reset to first available operation for the new metric type
+    const newAggregation = validOperations[0]?.value ?? 'avg';
+
+    const newAggregate = makeMetricsAggregate({
+      aggregate: newAggregation,
+      traceMetric: newMetric,
+    });
+    onChange(newAggregate, {});
+  };
 
   const traceMetricSelectValue = makeMetricSelectValue(
     hasMetricUnitsUI ? traceMetric : {name: traceMetric.name, type: traceMetric.type}
diff --git a/static/app/views/alerts/rules/uptime/assertionSuggestionsButton.tsx b/static/app/views/alerts/rules/uptime/assertionSuggestionsButton.tsx
index 1c8a7356783e01..becf5460e0782a 100644
--- a/static/app/views/alerts/rules/uptime/assertionSuggestionsButton.tsx
+++ b/static/app/views/alerts/rules/uptime/assertionSuggestionsButton.tsx
@@ -91,7 +91,7 @@ export function AssertionSuggestionsButton({
     [getCurrentAssertion, onApplySuggestion]
   );
 
-  const handleClick = useCallback(() => {
+  const handleClick = () => {
     const {url, timeoutMs, method, headers, body} = getFormData();
 
     if (!url) {
@@ -108,7 +108,7 @@ export function AssertionSuggestionsButton({
       ),
       {ariaLabel: t('AI Assertion Suggestions')}
     );
-  }, [getFormData, openDrawer, handleApplySuggestion]);
+  };
 
   return (
     <Button
diff --git a/static/app/views/alerts/rules/uptime/testUptimeMonitorButton.tsx b/static/app/views/alerts/rules/uptime/testUptimeMonitorButton.tsx
index 5109a665e7effc..ce991ce8e6819b 100644
--- a/static/app/views/alerts/rules/uptime/testUptimeMonitorButton.tsx
+++ b/static/app/views/alerts/rules/uptime/testUptimeMonitorButton.tsx
@@ -1,5 +1,3 @@
-import {useCallback} from 'react';
-
 import {Button, type ButtonProps} from '@sentry/scraps/button';
 
 import {addErrorMessage, addSuccessMessage} from 'sentry/actionCreators/indicator';
@@ -8,9 +6,9 @@ import {fetchMutation, useMutation} from 'sentry/utils/queryClient';
 import type {RequestError} from 'sentry/utils/requestError/requestError';
 import {useOrganization} from 'sentry/utils/useOrganization';
 import {
-  PreviewCheckStatus,
   type PreviewCheckPayload,
   type PreviewCheckResult,
+  PreviewCheckStatus,
   type UptimeAssertion,
 } from 'sentry/views/alerts/rules/uptime/types';
 
@@ -96,7 +94,7 @@ export function TestUptimeMonitorButton({
     },
   });
 
-  const handleTestClick = useCallback(() => {
+  const handleTestClick = () => {
     const formData = getFormData();
 
     if (!formData.url) {
@@ -112,7 +110,7 @@ export function TestUptimeMonitorButton({
       body: formData.body,
       assertion: formData.assertion,
     });
-  }, [getFormData, runPreviewCheck]);
+  };
 
   return (
     <Button onClick={handleTestClick} busy={isPending} disabled={isPending} size={size}>
diff --git a/static/app/views/automations/components/automationBuilder.tsx b/static/app/views/automations/components/automationBuilder.tsx
index e6085523435ab9..6a004bffc84f49 100644
--- a/static/app/views/automations/components/automationBuilder.tsx
+++ b/static/app/views/automations/components/automationBuilder.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useEffect, useMemo} from 'react';
+import {useEffect, useMemo} from 'react';
 import styled from '@emotion/styled';
 
 import {Alert} from '@sentry/scraps/alert';
@@ -13,9 +13,9 @@ import {IconAdd, IconDelete, IconMail} from 'sentry/icons';
 import {t, tct} from 'sentry/locale';
 import type {SelectValue} from 'sentry/types/core';
 import {
+  type DataConditionGroup,
   DataConditionGroupLogicType,
   DataConditionHandlerGroupType,
-  type DataConditionGroup,
 } from 'sentry/types/workflowEngine/dataConditions';
 import type {RequestError} from 'sentry/utils/requestError/requestError';
 import {useApi} from 'sentry/utils/useApi';
@@ -148,7 +148,7 @@ function ActionFilterBlock({actionFilter}: ActionFilterBlockProps) {
 
   const numActionFilters = state.actionFilters.length;
 
-  const handleSendTestNotification = useCallback(() => {
+  const handleSendTestNotification = () => {
     const actionFilterActions = actionFilter.actions || [];
 
     // Validate actions before sending test notification
@@ -163,7 +163,7 @@ function ActionFilterBlock({actionFilter}: ActionFilterBlockProps) {
         })
       );
     }
-  }, [actionFilter.actions, sendTestNotification, setErrors]);
+  };
 
   return (
     <IfThenWrapper>
diff --git a/static/app/views/automations/components/automationListTable/actions.tsx b/static/app/views/automations/components/automationListTable/actions.tsx
index a9ad989ea45060..a14a380e91a335 100644
--- a/static/app/views/automations/components/automationListTable/actions.tsx
+++ b/static/app/views/automations/components/automationListTable/actions.tsx
@@ -83,33 +83,21 @@ export function AutomationsTableActions({
     );
   }, [allInQuerySelected, queryCount, selected.size]);
 
-  const handleUpdate = useCallback(
-    ({enabled}: {enabled: boolean}) => {
-      openConfirmModal({
-        message: enabled ? getEnableConfirmMessage() : getDisableConfirmMessage(),
-        confirmText: enabled ? t('Enable') : t('Disable'),
-        priority: 'danger',
-        onConfirm: async () => {
-          if (allInQuerySelected) {
-            await updateAutomations({enabled, query, projects: selection.projects});
-          } else {
-            await updateAutomations({enabled, ids: Array.from(selected)});
-          }
-          togglePageSelected(false);
-        },
-      });
-    },
-    [
-      selected,
-      allInQuerySelected,
-      updateAutomations,
-      getEnableConfirmMessage,
-      getDisableConfirmMessage,
-      togglePageSelected,
-      selection.projects,
-      query,
-    ]
-  );
+  const handleUpdate = ({enabled}: {enabled: boolean}) => {
+    openConfirmModal({
+      message: enabled ? getEnableConfirmMessage() : getDisableConfirmMessage(),
+      confirmText: enabled ? t('Enable') : t('Disable'),
+      priority: 'danger',
+      onConfirm: async () => {
+        if (allInQuerySelected) {
+          await updateAutomations({enabled, query, projects: selection.projects});
+        } else {
+          await updateAutomations({enabled, ids: Array.from(selected)});
+        }
+        togglePageSelected(false);
+      },
+    });
+  };
 
   const getDeleteConfirmMessage = useCallback(() => {
     if (allInQuerySelected) {
@@ -127,7 +115,7 @@ export function AutomationsTableActions({
     );
   }, [allInQuerySelected, queryCount, selected.size]);
 
-  const handleDelete = useCallback(() => {
+  const handleDelete = () => {
     openConfirmModal({
       message: getDeleteConfirmMessage(),
       confirmText: t('Delete'),
@@ -141,15 +129,7 @@ export function AutomationsTableActions({
         togglePageSelected(false);
       },
     });
-  }, [
-    selected,
-    allInQuerySelected,
-    deleteAutomations,
-    getDeleteConfirmMessage,
-    togglePageSelected,
-    selection.projects,
-    query,
-  ]);
+  };
 
   return (
     <Fragment>
diff --git a/static/app/views/automations/components/editAutomationActions.tsx b/static/app/views/automations/components/editAutomationActions.tsx
index ae4e50c081eeaf..c503fe50aa4cfe 100644
--- a/static/app/views/automations/components/editAutomationActions.tsx
+++ b/static/app/views/automations/components/editAutomationActions.tsx
@@ -1,4 +1,3 @@
-import {useCallback} from 'react';
 import {Observer} from 'mobx-react-lite';
 
 import {Button} from '@sentry/scraps/button';
@@ -29,7 +28,7 @@ export function EditAutomationActions({automation, form}: EditAutomationActionsP
     useDeleteAutomationMutation();
   const {mutate: updateAutomation, isPending: isUpdating} = useUpdateAutomation();
 
-  const toggleDisabled = useCallback(() => {
+  const toggleDisabled = () => {
     const newEnabled = !automation.enabled;
     updateAutomation(
       {
@@ -43,9 +42,9 @@ export function EditAutomationActions({automation, form}: EditAutomationActionsP
         },
       }
     );
-  }, [updateAutomation, automation]);
+  };
 
-  const handleDelete = useCallback(() => {
+  const handleDelete = () => {
     openConfirmModal({
       message: t('Are you sure you want to delete this alert?'),
       confirmText: t('Delete'),
@@ -55,7 +54,7 @@ export function EditAutomationActions({automation, form}: EditAutomationActionsP
         navigate(makeAutomationBasePathname(organization.slug));
       },
     });
-  }, [deleteAutomation, automation.id, navigate, organization.slug]);
+  };
 
   return (
     <div>
diff --git a/static/app/views/automations/detail.tsx b/static/app/views/automations/detail.tsx
index 839e8ebd9767fe..c6e7cd6b274724 100644
--- a/static/app/views/automations/detail.tsx
+++ b/static/app/views/automations/detail.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback, useState} from 'react';
+import {Fragment, useState} from 'react';
 
 import {Alert} from '@sentry/scraps/alert';
 import {Button, LinkButton} from '@sentry/scraps/button';
@@ -216,7 +216,7 @@ function Actions({automation}: {automation: Automation}) {
   const organization = useOrganization();
   const {mutate: updateAutomation, isPending: isUpdating} = useUpdateAutomation();
 
-  const toggleDisabled = useCallback(() => {
+  const toggleDisabled = () => {
     const newEnabled = !automation.enabled;
     updateAutomation(
       {
@@ -230,7 +230,7 @@ function Actions({automation}: {automation: Automation}) {
         },
       }
     );
-  }, [updateAutomation, automation]);
+  };
 
   return (
     <Fragment>
diff --git a/static/app/views/dashboards/createFromSeerPrompt.tsx b/static/app/views/dashboards/createFromSeerPrompt.tsx
index f9271ced0b1a50..70771be3ca0e87 100644
--- a/static/app/views/dashboards/createFromSeerPrompt.tsx
+++ b/static/app/views/dashboards/createFromSeerPrompt.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useState} from 'react';
+import {useState} from 'react';
 
 import {Button} from '@sentry/scraps/button';
 import {Container, Flex, Stack} from '@sentry/scraps/layout';
@@ -23,7 +23,7 @@ export function CreateFromSeerPrompt() {
   const [isGenerating, setIsGenerating] = useState(false);
   const hasPageFrame = useHasPageFrameFeature();
 
-  const handleGenerate = useCallback(async () => {
+  const handleGenerate = async () => {
     if (!prompt.trim()) {
       return;
     }
@@ -59,7 +59,7 @@ export function CreateFromSeerPrompt() {
       setIsGenerating(false);
       addErrorMessage(t('Failed to start dashboard generation'));
     }
-  }, [prompt, organization.slug, location.query, navigate]);
+  };
 
   return (
     <Stack flex={1} padding="2xl 3xl" background={hasPageFrame ? undefined : 'secondary'}>
diff --git a/static/app/views/dashboards/dashboard.tsx b/static/app/views/dashboards/dashboard.tsx
index 1c052bbb0eaf29..94069d9e51d03e 100644
--- a/static/app/views/dashboards/dashboard.tsx
+++ b/static/app/views/dashboards/dashboard.tsx
@@ -303,29 +303,26 @@ function DashboardInner({
     [organization, dashboard.widgets, onEditWidget]
   );
 
-  const handleChangeSplitDataset = useCallback(
-    (widget: Widget, index: number) => {
-      const widgetCopy = cloneDeep({
-        ...widget,
-        id: undefined,
-      });
-
-      const nextList = [...dashboard.widgets];
-      const nextWidgetData = {
-        ...widgetCopy,
-        widgetType: WidgetType.TRANSACTIONS,
-        datasetSource: DatasetSource.USER,
-        id: widget.id,
-      };
-      nextList[index] = nextWidgetData;
+  const handleChangeSplitDataset = (widget: Widget, index: number) => {
+    const widgetCopy = cloneDeep({
+      ...widget,
+      id: undefined,
+    });
+
+    const nextList = [...dashboard.widgets];
+    const nextWidgetData = {
+      ...widgetCopy,
+      widgetType: WidgetType.TRANSACTIONS,
+      datasetSource: DatasetSource.USER,
+      id: widget.id,
+    };
+    nextList[index] = nextWidgetData;
 
-      onUpdate(nextList);
-      if (!isEditingDashboard) {
-        handleUpdateWidgetList(nextList);
-      }
-    },
-    [dashboard.widgets, onUpdate, isEditingDashboard, handleUpdateWidgetList]
-  );
+    onUpdate(nextList);
+    if (!isEditingDashboard) {
+      handleUpdateWidgetList(nextList);
+    }
+  };
 
   const handleLayoutChange = useCallback(
     (_: any, allLayouts: LayoutState) => {
diff --git a/static/app/views/dashboards/dashboardChatPanel.tsx b/static/app/views/dashboards/dashboardChatPanel.tsx
index b8014b6196dbbd..34f86e7d4ef926 100644
--- a/static/app/views/dashboards/dashboardChatPanel.tsx
+++ b/static/app/views/dashboards/dashboardChatPanel.tsx
@@ -74,24 +74,21 @@ export function DashboardChatPanel({
   }, [inputValue, isUpdating, onSend]);
 
   // Handle Enter key press to send message
-  const handleKeyDown = useCallback(
-    (e: React.KeyboardEvent<HTMLTextAreaElement>) => {
-      if (e.key === 'Enter' && !e.shiftKey) {
-        e.preventDefault();
-        handleSubmit();
-      }
-    },
-    [handleSubmit]
-  );
+  const handleKeyDown = (e: React.KeyboardEvent<HTMLTextAreaElement>) => {
+    if (e.key === 'Enter' && !e.shiftKey) {
+      e.preventDefault();
+      handleSubmit();
+    }
+  };
 
-  const handleInputChange = useCallback((e: React.ChangeEvent<HTMLTextAreaElement>) => {
+  const handleInputChange = (e: React.ChangeEvent<HTMLTextAreaElement>) => {
     setInputValue(e.target.value);
 
     // Auto-resize textarea
     const textarea = e.target;
     textarea.style.height = 'auto';
     textarea.style.height = `${Math.min(textarea.scrollHeight, 120)}px`;
-  }, []);
+  };
 
   const hasHistory = blocks.length > 0;
 
diff --git a/static/app/views/dashboards/widgetBuilder/components/saveButton.tsx b/static/app/views/dashboards/widgetBuilder/components/saveButton.tsx
index b4165aebbf6128..d76ad9f0c15303 100644
--- a/static/app/views/dashboards/widgetBuilder/components/saveButton.tsx
+++ b/static/app/views/dashboards/widgetBuilder/components/saveButton.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useState} from 'react';
+import {useState} from 'react';
 
 import {Button} from '@sentry/scraps/button';
 
@@ -12,7 +12,7 @@ import {DatasetSource} from 'sentry/utils/discover/types';
 import {useApi} from 'sentry/utils/useApi';
 import {useOrganization} from 'sentry/utils/useOrganization';
 import {useParams} from 'sentry/utils/useParams';
-import {WidgetType, type Widget} from 'sentry/views/dashboards/types';
+import {type Widget, WidgetType} from 'sentry/views/dashboards/types';
 import {flattenErrors} from 'sentry/views/dashboards/utils';
 import {useWidgetBuilderContext} from 'sentry/views/dashboards/widgetBuilder/contexts/widgetBuilderContext';
 import {useDisableTransactionWidget} from 'sentry/views/dashboards/widgetBuilder/hooks/useDisableTransactionWidget';
@@ -32,7 +32,7 @@ export function SaveButton({isEditing, onSave, setError}: SaveButtonProps) {
   const [isSaving, setIsSaving] = useState(false);
   const disableTransactionWidget = useDisableTransactionWidget();
 
-  const handleSave = useCallback(async () => {
+  const handleSave = async () => {
     trackAnalytics('dashboards_views.widget_builder.save', {
       builder_version: WidgetBuilderVersion.SLIDEOUT,
       data_set: state.dataset ?? '',
@@ -58,7 +58,7 @@ export function SaveButton({isEditing, onSave, setError}: SaveButtonProps) {
       }
       addErrorMessage(errorMessage);
     }
-  }, [api, onSave, organization, state, widgetIndex, setError, isEditing]);
+  };
 
   return (
     <Button
diff --git a/static/app/views/dashboards/widgetBuilder/components/widgetTemplatesList.tsx b/static/app/views/dashboards/widgetBuilder/components/widgetTemplatesList.tsx
index 8f63bd2a3cba3e..9d3a4d02cac797 100644
--- a/static/app/views/dashboards/widgetBuilder/components/widgetTemplatesList.tsx
+++ b/static/app/views/dashboards/widgetBuilder/components/widgetTemplatesList.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback, useEffect, useState} from 'react';
+import {Fragment, useEffect, useState} from 'react';
 import {useParams} from 'react-router-dom';
 import {useTheme} from '@emotion/react';
 import styled from '@emotion/styled';
@@ -75,18 +75,15 @@ export function WidgetTemplatesList({
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
-  const handleSave = useCallback(
-    async (widget: Widget) => {
-      try {
-        const newWidget = {...widget, id: undefined};
-        await validateWidget(api, organization.slug, newWidget);
-        onSave({index: Number(widgetIndex), widget: newWidget});
-      } catch (error) {
-        addErrorMessage(t('Unable to add widget'));
-      }
-    },
-    [api, organization.slug, widgetIndex, onSave]
-  );
+  const handleSave = async (widget: Widget) => {
+    try {
+      const newWidget = {...widget, id: undefined};
+      await validateWidget(api, organization.slug, newWidget);
+      onSave({index: Number(widgetIndex), widget: newWidget});
+    } catch (error) {
+      addErrorMessage(t('Unable to add widget'));
+    }
+  };
 
   return (
     <Fragment>
diff --git a/static/app/views/detectors/components/details/common/actions.tsx b/static/app/views/detectors/components/details/common/actions.tsx
index 48772c723aff60..222375dae3f7f6 100644
--- a/static/app/views/detectors/components/details/common/actions.tsx
+++ b/static/app/views/detectors/components/details/common/actions.tsx
@@ -1,5 +1,3 @@
-import {useCallback} from 'react';
-
 import {Button, LinkButton} from '@sentry/scraps/button';
 import {Tooltip} from '@sentry/scraps/tooltip';
 
@@ -26,7 +24,7 @@ import {useCanEditDetector} from 'sentry/views/detectors/utils/useCanEditDetecto
 export function DisableDetectorAction({detector}: {detector: Detector}) {
   const {mutate: updateDetector, isPending: isUpdating} = useUpdateDetector();
 
-  const toggleDisabled = useCallback(() => {
+  const toggleDisabled = () => {
     const newEnabled = !detector.enabled;
     updateDetector(
       {
@@ -39,7 +37,7 @@ export function DisableDetectorAction({detector}: {detector: Detector}) {
         },
       }
     );
-  }, [updateDetector, detector.enabled, detector.id]);
+  };
 
   const canEdit = useCanEditDetector({
     detectorType: detector.type,
@@ -100,7 +98,7 @@ export function DeleteDetectorAction({detector}: {detector: Detector}) {
   const {mutateAsync: deleteDetector, isPending: isDeleting} =
     useDeleteDetectorMutation();
 
-  const handleDelete = useCallback(() => {
+  const handleDelete = () => {
     openConfirmModal({
       message: t('Are you sure you want to delete this monitor?'),
       confirmText: t('Delete'),
@@ -110,7 +108,7 @@ export function DeleteDetectorAction({detector}: {detector: Detector}) {
         navigate(makeMonitorTypePathname(organization.slug, detector.type));
       },
     });
-  }, [deleteDetector, detector.id, detector.type, navigate, organization.slug]);
+  };
 
   const canEdit = useCanEditDetector({
     detectorType: detector.type,
diff --git a/static/app/views/detectors/components/detectorListTable/actions.tsx b/static/app/views/detectors/components/detectorListTable/actions.tsx
index 66a5b2eff60016..47dc833c4f05d6 100644
--- a/static/app/views/detectors/components/detectorListTable/actions.tsx
+++ b/static/app/views/detectors/components/detectorListTable/actions.tsx
@@ -90,33 +90,21 @@ export function DetectorsTableActions({
     );
   }, [allInQuerySelected, queryCount, selected.size]);
 
-  const handleUpdate = useCallback(
-    ({enabled}: {enabled: boolean}) => {
-      openConfirmModal({
-        message: enabled ? getEnableConfirmMessage() : getDisableConfirmMessage(),
-        confirmText: enabled ? t('Enable') : t('Disable'),
-        priority: 'danger',
-        onConfirm: async () => {
-          if (allInQuerySelected) {
-            await updateDetectors({enabled, query, projects: selection.projects});
-          } else {
-            await updateDetectors({enabled, ids: Array.from(selected)});
-          }
-          togglePageSelected(false);
-        },
-      });
-    },
-    [
-      selected,
-      allInQuerySelected,
-      updateDetectors,
-      getEnableConfirmMessage,
-      getDisableConfirmMessage,
-      togglePageSelected,
-      selection.projects,
-      query,
-    ]
-  );
+  const handleUpdate = ({enabled}: {enabled: boolean}) => {
+    openConfirmModal({
+      message: enabled ? getEnableConfirmMessage() : getDisableConfirmMessage(),
+      confirmText: enabled ? t('Enable') : t('Disable'),
+      priority: 'danger',
+      onConfirm: async () => {
+        if (allInQuerySelected) {
+          await updateDetectors({enabled, query, projects: selection.projects});
+        } else {
+          await updateDetectors({enabled, ids: Array.from(selected)});
+        }
+        togglePageSelected(false);
+      },
+    });
+  };
 
   const getDeleteConfirmMessage = useCallback(() => {
     if (allInQuerySelected) {
@@ -134,7 +122,7 @@ export function DetectorsTableActions({
     );
   }, [allInQuerySelected, queryCount, selected.size]);
 
-  const handleDelete = useCallback(() => {
+  const handleDelete = () => {
     openConfirmModal({
       message: getDeleteConfirmMessage(),
       confirmText: t('Delete'),
@@ -148,15 +136,7 @@ export function DetectorsTableActions({
         togglePageSelected(false);
       },
     });
-  }, [
-    selected,
-    allInQuerySelected,
-    deleteDetectors,
-    getDeleteConfirmMessage,
-    togglePageSelected,
-    selection.projects,
-    query,
-  ]);
+  };
 
   return (
     <Fragment>
diff --git a/static/app/views/detectors/components/forms/metric/metricsVisualize.tsx b/static/app/views/detectors/components/forms/metric/metricsVisualize.tsx
index 1f39a79de24e96..9ee98ac0d86cc1 100644
--- a/static/app/views/detectors/components/forms/metric/metricsVisualize.tsx
+++ b/static/app/views/detectors/components/forms/metric/metricsVisualize.tsx
@@ -178,23 +178,20 @@ export function MetricsVisualize() {
     [updateFormAggregate, traceMetric]
   );
 
-  const handleMetricChange = useCallback(
-    (option: MetricSelectOption) => {
-      const newMetric: TraceMetric = {
-        name: option.metricName,
-        type: option.metricType,
-        unit: hasMetricUnitsUI ? (option.metricUnit ?? NONE_UNIT) : undefined,
-      };
-      const newMetricType = option.metricType?.toLowerCase() ?? '';
-      const validOperations = OPTIONS_BY_TYPE[newMetricType] ?? [];
-      const newAggregation = validOperations[0]?.value ?? 'avg';
+  const handleMetricChange = (option: MetricSelectOption) => {
+    const newMetric: TraceMetric = {
+      name: option.metricName,
+      type: option.metricType,
+      unit: hasMetricUnitsUI ? (option.metricUnit ?? NONE_UNIT) : undefined,
+    };
+    const newMetricType = option.metricType?.toLowerCase() ?? '';
+    const validOperations = OPTIONS_BY_TYPE[newMetricType] ?? [];
+    const newAggregation = validOperations[0]?.value ?? 'avg';
 
-      updateFormAggregate(
-        makeMetricsAggregate({aggregate: newAggregation, traceMetric: newMetric})
-      );
-    },
-    [updateFormAggregate, hasMetricUnitsUI]
-  );
+    updateFormAggregate(
+      makeMetricsAggregate({aggregate: newAggregation, traceMetric: newMetric})
+    );
+  };
 
   // Auto-select the first metric when options load and none is selected
   useEffect(() => {
diff --git a/static/app/views/explore/components/schemaHints/schemaHintsDrawer.tsx b/static/app/views/explore/components/schemaHints/schemaHintsDrawer.tsx
index f92a57af0afc3e..9a1c199408dd56 100644
--- a/static/app/views/explore/components/schemaHints/schemaHintsDrawer.tsx
+++ b/static/app/views/explore/components/schemaHints/schemaHintsDrawer.tsx
@@ -98,51 +98,48 @@ export function SchemaHintsDrawer({
 
   const virtualItems = virtualizer.getVirtualItems();
 
-  const handleCheckboxChange = useCallback(
-    (hint: Tag) => {
-      const filterQuery = new MutableSearch(queryRef.current);
-      if (
-        filterQuery
-          .getFilterKeys()
+  const handleCheckboxChange = (hint: Tag) => {
+    const filterQuery = new MutableSearch(queryRef.current);
+    if (
+      filterQuery
+        .getFilterKeys()
+        .map(parseTagKey)
+        .some(key => key === hint.key || key === `!${hint.key}`)
+    ) {
+      const keyToRemove =
+        hint.kind === FieldKind.FUNCTION
+          ? (filterQuery
+              .getFilterKeys()
+              .find(key => parseFunction(key)?.name === hint.key) ?? '')
+          : hint.key;
+      // remove hint and/or negated hint if it exists
+      filterQuery.removeFilter(keyToRemove);
+      filterQuery.removeFilter(`!${keyToRemove}`);
+    } else {
+      const hintFieldDefinition = getFieldDefinition(hint.key, 'span', hint.kind);
+      addFilterToQuery(filterQuery, hint, hintFieldDefinition);
+    }
+
+    handleQueryChange(filterQuery);
+    searchBarDispatch({
+      type: 'UPDATE_QUERY',
+      query: filterQuery.formatString(),
+      focusOverride: {
+        itemKey: `filter:${filterQuery
+          .getTokenKeys()
+          .filter(key => key !== undefined)
           .map(parseTagKey)
-          .some(key => key === hint.key || key === `!${hint.key}`)
-      ) {
-        const keyToRemove =
-          hint.kind === FieldKind.FUNCTION
-            ? (filterQuery
-                .getFilterKeys()
-                .find(key => parseFunction(key)?.name === hint.key) ?? '')
-            : hint.key;
-        // remove hint and/or negated hint if it exists
-        filterQuery.removeFilter(keyToRemove);
-        filterQuery.removeFilter(`!${keyToRemove}`);
-      } else {
-        const hintFieldDefinition = getFieldDefinition(hint.key, 'span', hint.kind);
-        addFilterToQuery(filterQuery, hint, hintFieldDefinition);
-      }
-
-      handleQueryChange(filterQuery);
-      searchBarDispatch({
-        type: 'UPDATE_QUERY',
-        query: filterQuery.formatString(),
-        focusOverride: {
-          itemKey: `filter:${filterQuery
-            .getTokenKeys()
-            .filter(key => key !== undefined)
-            .map(parseTagKey)
-            .lastIndexOf(hint.key)}`,
-          part: 'value',
-        },
-        shouldCommitQuery: false,
-      });
-      trackAnalytics('trace.explorer.schema_hints_click', {
-        hint_key: hint.key,
-        source: 'drawer',
-        organization,
-      });
-    },
-    [handleQueryChange, organization, queryRef, searchBarDispatch]
-  );
+          .lastIndexOf(hint.key)}`,
+        part: 'value',
+      },
+      shouldCommitQuery: false,
+    });
+    trackAnalytics('trace.explorer.schema_hints_click', {
+      hint_key: hint.key,
+      source: 'drawer',
+      organization,
+    });
+  };
 
   const noAttributesMessage = (
     <NoAttributesMessage>
diff --git a/static/app/views/explore/components/schemaHints/schemaHintsList.tsx b/static/app/views/explore/components/schemaHints/schemaHintsList.tsx
index bb80f0884f31c4..17fad4f95d22cc 100644
--- a/static/app/views/explore/components/schemaHints/schemaHintsList.tsx
+++ b/static/app/views/explore/components/schemaHints/schemaHintsList.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useEffect, useMemo, useRef, useState} from 'react';
+import {useEffect, useMemo, useRef, useState} from 'react';
 import {css, useTheme} from '@emotion/react';
 import styled from '@emotion/styled';
 import debounce from 'lodash/debounce';
@@ -18,12 +18,12 @@ import type {Tag, TagCollection} from 'sentry/types/group';
 import {trackAnalytics} from 'sentry/utils/analytics';
 import {isAggregateField, parseFunction} from 'sentry/utils/discover/fields';
 import {
+  type AggregationKey,
+  type FieldDefinition,
   FieldKind,
   FieldValueType,
   getFieldDefinition,
   prettifyTagKey,
-  type AggregationKey,
-  type FieldDefinition,
 } from 'sentry/utils/fields';
 import {MutableSearch} from 'sentry/utils/tokenizeSearch';
 import {useLocation} from 'sentry/utils/useLocation';
@@ -313,114 +313,100 @@ export function SchemaHintsList({
     return () => resizeObserver.disconnect();
   }, [isDrawerOpen, panelRef, searchBarWidthOffset, searchBarWrapperRef]);
 
-  const onHintClick = useCallback(
-    (hint: Tag) => {
-      if (hint.key === seeFullListTag.key) {
-        if (!isDrawerOpen) {
-          setIsDrawerOpen(true);
-          openDrawer(
-            () => (
-              <SchemaHintsDrawer
-                hints={fullFilterTagsSorted}
-                exploreQuery={query}
-                searchBarDispatch={dispatch}
-                queryRef={queryRef}
-              />
-            ),
-            {
-              ariaLabel: t('Schema Hints Drawer'),
-              drawerWidth: SCHEMA_HINTS_DRAWER_WIDTH,
-              drawerKey: 'schema-hints-drawer',
-              resizable: true,
-              drawerCss: css`
-                height: calc(100% - ${theme.space['3xl']});
-              `,
-              shouldCloseOnLocationChange: newLocation => {
-                return (
-                  location.pathname !== newLocation.pathname ||
-                  // will close if anything but the filter query has changed
-                  !isEqual(
-                    omit(location.query, [
-                      'query',
-                      'field',
-                      LOGS_FIELDS_KEY,
-                      LOGS_QUERY_KEY,
-                    ]),
-                    omit(newLocation.query, [
-                      'query',
-                      'field',
-                      LOGS_FIELDS_KEY,
-                      LOGS_QUERY_KEY,
-                    ])
-                  )
-                );
-              },
-              onOpen: () => {
-                trackAnalytics('trace.explorer.schema_hints_drawer', {
-                  drawer_open: true,
-                  organization,
-                });
-                if (searchBarWrapperRef.current) {
-                  searchBarWrapperRef.current.style.minWidth = '20%';
-                }
-              },
-
-              onClose: () => {
-                setIsDrawerOpen(false);
-                trackAnalytics('trace.explorer.schema_hints_drawer', {
-                  drawer_open: false,
-                  organization,
-                });
-                if (searchBarWrapperRef.current) {
-                  searchBarWrapperRef.current.style.width = '100%';
-                  searchBarWrapperRef.current.style.minWidth = '';
-                }
-              },
-            }
-          );
-        }
-        return;
+  const onHintClick = (hint: Tag) => {
+    if (hint.key === seeFullListTag.key) {
+      if (!isDrawerOpen) {
+        setIsDrawerOpen(true);
+        openDrawer(
+          () => (
+            <SchemaHintsDrawer
+              hints={fullFilterTagsSorted}
+              exploreQuery={query}
+              searchBarDispatch={dispatch}
+              queryRef={queryRef}
+            />
+          ),
+          {
+            ariaLabel: t('Schema Hints Drawer'),
+            drawerWidth: SCHEMA_HINTS_DRAWER_WIDTH,
+            drawerKey: 'schema-hints-drawer',
+            resizable: true,
+            drawerCss: css`
+              height: calc(100% - ${theme.space['3xl']});
+            `,
+            shouldCloseOnLocationChange: newLocation => {
+              return (
+                location.pathname !== newLocation.pathname ||
+                // will close if anything but the filter query has changed
+                !isEqual(
+                  omit(location.query, [
+                    'query',
+                    'field',
+                    LOGS_FIELDS_KEY,
+                    LOGS_QUERY_KEY,
+                  ]),
+                  omit(newLocation.query, [
+                    'query',
+                    'field',
+                    LOGS_FIELDS_KEY,
+                    LOGS_QUERY_KEY,
+                  ])
+                )
+              );
+            },
+            onOpen: () => {
+              trackAnalytics('trace.explorer.schema_hints_drawer', {
+                drawer_open: true,
+                organization,
+              });
+              if (searchBarWrapperRef.current) {
+                searchBarWrapperRef.current.style.minWidth = '20%';
+              }
+            },
+
+            onClose: () => {
+              setIsDrawerOpen(false);
+              trackAnalytics('trace.explorer.schema_hints_drawer', {
+                drawer_open: false,
+                organization,
+              });
+              if (searchBarWrapperRef.current) {
+                searchBarWrapperRef.current.style.width = '100%';
+                searchBarWrapperRef.current.style.minWidth = '';
+              }
+            },
+          }
+        );
       }
+      return;
+    }
+
+    const newSearchQuery = new MutableSearch(query);
+    const fieldDefinition = getFieldDefinition(hint.key, 'span', hint.kind);
+    addFilterToQuery(newSearchQuery, hint, fieldDefinition);
+
+    const newQuery = newSearchQuery.formatString();
+
+    dispatch({
+      type: 'UPDATE_QUERY',
+      query: newQuery,
+      focusOverride: {
+        itemKey: `filter:${newSearchQuery
+          .getTokenKeys()
+          .filter(key => key !== undefined)
+          .map(parseTagKey)
+          .lastIndexOf(hint.key)}`,
+        part: 'value',
+      },
+      shouldCommitQuery: false,
+    });
 
-      const newSearchQuery = new MutableSearch(query);
-      const fieldDefinition = getFieldDefinition(hint.key, 'span', hint.kind);
-      addFilterToQuery(newSearchQuery, hint, fieldDefinition);
-
-      const newQuery = newSearchQuery.formatString();
-
-      dispatch({
-        type: 'UPDATE_QUERY',
-        query: newQuery,
-        focusOverride: {
-          itemKey: `filter:${newSearchQuery
-            .getTokenKeys()
-            .filter(key => key !== undefined)
-            .map(parseTagKey)
-            .lastIndexOf(hint.key)}`,
-          part: 'value',
-        },
-        shouldCommitQuery: false,
-      });
-
-      trackAnalytics('trace.explorer.schema_hints_click', {
-        hint_key: hint.key,
-        source: 'list',
-        organization,
-      });
-    },
-    [
-      query,
-      dispatch,
+    trackAnalytics('trace.explorer.schema_hints_click', {
+      hint_key: hint.key,
+      source: 'list',
       organization,
-      isDrawerOpen,
-      searchBarWrapperRef,
-      openDrawer,
-      fullFilterTagsSorted,
-      location.pathname,
-      location.query,
-      theme.space,
-    ]
-  );
+    });
+  };
 
   const getHintText = (hint: Tag) => {
     if (hint.key === seeFullListTag.key) {
diff --git a/static/app/views/explore/logs/logsTab.tsx b/static/app/views/explore/logs/logsTab.tsx
index a2c10489ad57c0..a48c6eb5616729 100644
--- a/static/app/views/explore/logs/logsTab.tsx
+++ b/static/app/views/explore/logs/logsTab.tsx
@@ -321,7 +321,7 @@ export function LogsTabContent({datePageFilterProps, tableExpando}: LogsTabProps
     aggregateSortBys,
   });
 
-  const refreshTable = useCallback(async () => {
+  const refreshTable = async () => {
     setTimeseriesIngestDelay(getMaxIngestDelayTimestamp());
     queryClient.setQueryData(
       tableData.queryKey,
@@ -337,7 +337,7 @@ export function LogsTabContent({datePageFilterProps, tableExpando}: LogsTabProps
       }
     );
     await tableData.refetch();
-  }, [tableData, queryClient]);
+  };
 
   const onColumnsChange = useCallback(
     (newFields: string[]) => {
@@ -350,7 +350,7 @@ export function LogsTabContent({datePageFilterProps, tableExpando}: LogsTabProps
     [setFields, setPersistentParams]
   );
 
-  const openColumnEditor = useCallback(() => {
+  const openColumnEditor = () => {
     openModal(
       modalProps => (
         <ColumnEditorModal
@@ -369,20 +369,17 @@ export function LogsTabContent({datePageFilterProps, tableExpando}: LogsTabProps
       ),
       {closeEvents: 'escape-key'}
     );
-  }, [booleanAttributes, fields, numberAttributes, onColumnsChange, stringAttributes]);
+  };
 
   const tableTab = mode === Mode.AGGREGATE ? 'aggregates' : 'logs';
-  const setTableTab = useCallback(
-    (tab: 'aggregates' | 'logs') => {
-      if (tab === 'aggregates') {
-        setSidebarOpen(true);
-        setMode(Mode.AGGREGATE);
-      } else {
-        setMode(Mode.SAMPLES);
-      }
-    },
-    [setSidebarOpen, setMode]
-  );
+  const setTableTab = (tab: 'aggregates' | 'logs') => {
+    if (tab === 'aggregates') {
+      setSidebarOpen(true);
+      setMode(Mode.AGGREGATE);
+    } else {
+      setMode(Mode.SAMPLES);
+    }
+  };
 
   /**
    * Manual refresh doesn't work for longer relative periods as it hits cacheing. Only allow manual refresh if the relative period or absolute time range is less than 1 hour.
diff --git a/static/app/views/explore/logs/logsToolbar.tsx b/static/app/views/explore/logs/logsToolbar.tsx
index a02643fa71c948..c0126ef64c9514 100644
--- a/static/app/views/explore/logs/logsToolbar.tsx
+++ b/static/app/views/explore/logs/logsToolbar.tsx
@@ -153,18 +153,15 @@ function ToolbarVisualize() {
     setVisualizes(newVisualizes);
   }, [setVisualizes, visualizes]);
 
-  const replaceOverlay = useCallback(
-    (group: number, newVisualize: Visualize) => {
-      const newVisualizes = visualizes.map((visualize, i) => {
-        if (i === group) {
-          return newVisualize.serialize();
-        }
-        return visualize.serialize();
-      });
-      setVisualizes(newVisualizes);
-    },
-    [setVisualizes, visualizes]
-  );
+  const replaceOverlay = (group: number, newVisualize: Visualize) => {
+    const newVisualizes = visualizes.map((visualize, i) => {
+      if (i === group) {
+        return newVisualize.serialize();
+      }
+      return visualize.serialize();
+    });
+    setVisualizes(newVisualizes);
+  };
 
   const handleDelete = useCallback(
     (group: number) => {
diff --git a/static/app/views/explore/logs/tables/logsTableRow.tsx b/static/app/views/explore/logs/tables/logsTableRow.tsx
index f1977b6caf2c79..b113e59c888acb 100644
--- a/static/app/views/explore/logs/tables/logsTableRow.tsx
+++ b/static/app/views/explore/logs/tables/logsTableRow.tsx
@@ -1,13 +1,5 @@
 import type {ComponentProps, SyntheticEvent} from 'react';
-import React, {
-  Fragment,
-  memo,
-  useCallback,
-  useLayoutEffect,
-  useMemo,
-  useRef,
-  useState,
-} from 'react';
+import React, {Fragment, memo, useLayoutEffect, useMemo, useRef, useState} from 'react';
 import {useTheme} from '@emotion/react';
 import classNames from 'classnames';
 import omit from 'lodash/omit';
@@ -93,8 +85,8 @@ import {
   getLogSeverityLevel,
   isPseudoLogResponseItem,
   isRegularLogResponseItem,
-  ourlogToJson,
   type LogTableRowItem,
+  ourlogToJson,
 } from 'sentry/views/explore/logs/utils';
 import type {ReplayEmbeddedTableOptions} from 'sentry/views/explore/logs/utils/logsReplayUtils';
 import {
@@ -663,7 +655,7 @@ function LogRowDetailsActions({
   // Memoize in case we are attempting to copy large JSON objects.
   const json = useMemo(() => ourlogToJson(data), [data]);
 
-  const betterCopyToClipboard = useCallback(() => {
+  const betterCopyToClipboard = () => {
     if (!json) {
       return;
     }
@@ -676,7 +668,7 @@ function LogRowDetailsActions({
         organization,
       });
     });
-  }, [copy, organization, tableDataRow, json]);
+  };
 
   return (
     <Fragment>
diff --git a/static/app/views/explore/metrics/metricToolbar/metricSelector.tsx b/static/app/views/explore/metrics/metricToolbar/metricSelector.tsx
index bf38943633437f..10c9f581fea733 100644
--- a/static/app/views/explore/metrics/metricToolbar/metricSelector.tsx
+++ b/static/app/views/explore/metrics/metricToolbar/metricSelector.tsx
@@ -394,9 +394,9 @@ export function MetricSelector({
     id: triggerId,
   });
 
-  const onSearchChange = useCallback((e: React.ChangeEvent<HTMLInputElement>) => {
+  const onSearchChange = (e: React.ChangeEvent<HTMLInputElement>) => {
     setSearchInputValue(e.target.value);
-  }, []);
+  };
 
   const virtualItems = virtualizer.getVirtualItems();
 
diff --git a/static/app/views/explore/tables/aggregateColumnEditorModal.tsx b/static/app/views/explore/tables/aggregateColumnEditorModal.tsx
index a5cde124d9acec..fe794f2c642b4f 100644
--- a/static/app/views/explore/tables/aggregateColumnEditorModal.tsx
+++ b/static/app/views/explore/tables/aggregateColumnEditorModal.tsx
@@ -89,7 +89,7 @@ export function AggregateColumnEditorModal({
     return columns.filter(isGroupBy).map(groupBy => groupBy.groupBy);
   }, [columns]);
 
-  const handleApply = useCallback(() => {
+  const handleApply = () => {
     const newColumns: WritableAggregateField[] = [];
 
     for (const col of tempColumns) {
@@ -102,7 +102,7 @@ export function AggregateColumnEditorModal({
 
     onColumnsChange(newColumns);
     closeModal();
-  }, [closeModal, onColumnsChange, tempColumns]);
+  };
 
   const groupByColumnss = tempColumns.filter(isGroupBy);
   const visualizeColumns = tempColumns.filter(isVisualize);
@@ -382,21 +382,18 @@ function AggregateSelector({
     [parsedFunction, onChange, visualize]
   );
 
-  const handleArgumentChange = useCallback(
-    (index: number, option: SelectOption<SelectKey>) => {
-      if (typeof option.value === 'string') {
-        let args = cloneDeep(parsedFunction?.arguments);
-        if (args) {
-          args[index] = option.value;
-        } else {
-          args = [option.value];
-        }
-        const newYAxis = `${parsedFunction?.name}(${args.join(',')})`;
-        onChange(visualize.replace({yAxis: newYAxis}));
+  const handleArgumentChange = (index: number, option: SelectOption<SelectKey>) => {
+    if (typeof option.value === 'string') {
+      let args = cloneDeep(parsedFunction?.arguments);
+      if (args) {
+        args[index] = option.value;
+      } else {
+        args = [option.value];
       }
-    },
-    [parsedFunction, onChange, visualize]
-  );
+      const newYAxis = `${parsedFunction?.name}(${args.join(',')})`;
+      onChange(visualize.replace({yAxis: newYAxis}));
+    }
+  };
 
   return (
     <Fragment>
diff --git a/static/app/views/explore/tables/index.tsx b/static/app/views/explore/tables/index.tsx
index 5e1d7b767105e1..5a9bd53f328421 100644
--- a/static/app/views/explore/tables/index.tsx
+++ b/static/app/views/explore/tables/index.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback, useEffect} from 'react';
+import {Fragment, useEffect} from 'react';
 
 import {Badge} from '@sentry/scraps/badge';
 import {Button} from '@sentry/scraps/button';
@@ -56,7 +56,7 @@ export function ExploreTables(props: ExploreTablesProps) {
   const {attributes: stringTags} = useSpanItemAttributes({}, 'string');
   const {attributes: booleanTags} = useSpanItemAttributes({}, 'boolean');
 
-  const openColumnEditor = useCallback(() => {
+  const openColumnEditor = () => {
     openModal(
       modalProps => (
         <ColumnEditorModal
@@ -70,9 +70,9 @@ export function ExploreTables(props: ExploreTablesProps) {
       ),
       {closeEvents: 'escape-key'}
     );
-  }, [booleanTags, fields, numberTags, setFields, stringTags]);
+  };
 
-  const openAggregateColumnEditor = useCallback(() => {
+  const openAggregateColumnEditor = () => {
     openModal(
       modalProps => (
         <AggregateColumnEditorModal
@@ -86,7 +86,7 @@ export function ExploreTables(props: ExploreTablesProps) {
       ),
       {closeEvents: 'escape-key'}
     );
-  }, [aggregateFields, booleanTags, numberTags, setAggregateFields, stringTags]);
+  };
 
   useEffect(() => {
     if (
diff --git a/static/app/views/explore/toolbar/toolbarSortBy.tsx b/static/app/views/explore/toolbar/toolbarSortBy.tsx
index 6bcf7dc02b5896..7349e6f004a362 100644
--- a/static/app/views/explore/toolbar/toolbarSortBy.tsx
+++ b/static/app/views/explore/toolbar/toolbarSortBy.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useMemo} from 'react';
+import {useMemo} from 'react';
 import styled from '@emotion/styled';
 
 import type {SelectKey, SelectOption} from '@sentry/scraps/compactSelect';
@@ -58,19 +58,16 @@ export function ToolbarSortBy() {
     mode,
   });
 
-  const setSortField = useCallback(
-    (i: number, {value}: SelectOption<SelectKey>) => {
-      if (sorts[i] && typeof value === 'string') {
-        setSorts([
-          {
-            field: value,
-            kind: sorts[i].kind,
-          },
-        ]);
-      }
-    },
-    [setSorts, sorts]
-  );
+  const setSortField = (i: number, {value}: SelectOption<SelectKey>) => {
+    if (sorts[i] && typeof value === 'string') {
+      setSorts([
+        {
+          field: value,
+          kind: sorts[i].kind,
+        },
+      ]);
+    }
+  };
 
   const kindOptions: Array<SelectOption<Sort['kind']>> = useMemo(() => {
     return [
@@ -87,19 +84,16 @@ export function ToolbarSortBy() {
     ];
   }, []);
 
-  const setSortKind = useCallback(
-    (i: number, {value}: SelectOption<SelectKey>) => {
-      if (sorts[i]) {
-        setSorts([
-          {
-            field: sorts[i].field,
-            kind: value as Sort['kind'],
-          },
-        ]);
-      }
-    },
-    [setSorts, sorts]
-  );
+  const setSortKind = (i: number, {value}: SelectOption<SelectKey>) => {
+    if (sorts[i]) {
+      setSorts([
+        {
+          field: sorts[i].field,
+          kind: value as Sort['kind'],
+        },
+      ]);
+    }
+  };
 
   let toolbarRow = (
     <ToolbarRow>
diff --git a/static/app/views/explore/toolbar/toolbarVisualize.tsx b/static/app/views/explore/toolbar/toolbarVisualize.tsx
index 663f7aa2085184..57e7ae7839d957 100644
--- a/static/app/views/explore/toolbar/toolbarVisualize.tsx
+++ b/static/app/views/explore/toolbar/toolbarVisualize.tsx
@@ -63,31 +63,25 @@ export function ToolbarVisualize({
     setVisualizes(newVisualizes);
   }, [setVisualizes, visualizes]);
 
-  const replaceOverlay = useCallback(
-    (group: number, newVisualize: Visualize) => {
-      const newVisualizes = visualizes.map((visualize, i) => {
-        if (i === group) {
-          return newVisualize.serialize();
-        }
-        return visualize.serialize();
-      });
-      setVisualizes(newVisualizes);
-    },
-    [setVisualizes, visualizes]
-  );
+  const replaceOverlay = (group: number, newVisualize: Visualize) => {
+    const newVisualizes = visualizes.map((visualize, i) => {
+      if (i === group) {
+        return newVisualize.serialize();
+      }
+      return visualize.serialize();
+    });
+    setVisualizes(newVisualizes);
+  };
 
-  const toggleVisibility = useCallback(
-    (group: number) => {
-      const newVisualizes = visualizes.map((visualize, i) => {
-        if (i === group) {
-          visualize = visualize.replace({visible: !visualize.visible});
-        }
-        return visualize.serialize();
-      });
-      setVisualizes(newVisualizes);
-    },
-    [setVisualizes, visualizes]
-  );
+  const toggleVisibility = (group: number) => {
+    const newVisualizes = visualizes.map((visualize, i) => {
+      if (i === group) {
+        visualize = visualize.replace({visible: !visualize.visible});
+      }
+      return visualize.serialize();
+    });
+    setVisualizes(newVisualizes);
+  };
 
   const handleOnDelete = useCallback(
     (group: number) => {
diff --git a/static/app/views/insights/crons/components/timezoneOverride.tsx b/static/app/views/insights/crons/components/timezoneOverride.tsx
index af8282352d9bfe..fe45968fadc4ee 100644
--- a/static/app/views/insights/crons/components/timezoneOverride.tsx
+++ b/static/app/views/insights/crons/components/timezoneOverride.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useMemo, useState} from 'react';
+import {useMemo, useState} from 'react';
 import styled from '@emotion/styled';
 import moment from 'moment-timezone';
 
@@ -34,13 +34,10 @@ export function TimezoneOverride({
     [monitorTimezone, userTimezone]
   );
 
-  const handleChange = useCallback(
-    (newMode: Mode) => {
-      setMode(newMode);
-      onTimezoneSelected(timezoneMapping[newMode]);
-    },
-    [onTimezoneSelected, timezoneMapping]
-  );
+  const handleChange = (newMode: Mode) => {
+    setMode(newMode);
+    onTimezoneSelected(timezoneMapping[newMode]);
+  };
 
   return (
     <CompactSelect
diff --git a/static/app/views/insights/pages/agents/components/drawer.tsx b/static/app/views/insights/pages/agents/components/drawer.tsx
index ad519edc22e675..011698cb86cc6e 100644
--- a/static/app/views/insights/pages/agents/components/drawer.tsx
+++ b/static/app/views/insights/pages/agents/components/drawer.tsx
@@ -67,12 +67,12 @@ const TraceViewDrawer = memo(function TraceViewDrawer({
     source: TraceViewSources.AGENT_MONITORING,
   });
 
-  const handleViewFullTraceClick = useCallback(() => {
+  const handleViewFullTraceClick = () => {
     trackAnalytics('agent-monitoring.drawer.view-full-trace-click', {
       organization,
     });
     closeDrawer();
-  }, [organization, closeDrawer]);
+  };
 
   return (
     <Stack height="100%">
diff --git a/static/app/views/insights/pages/agents/components/tracesTable.tsx b/static/app/views/insights/pages/agents/components/tracesTable.tsx
index cf314f80d3e107..6cf019c02091fc 100644
--- a/static/app/views/insights/pages/agents/components/tracesTable.tsx
+++ b/static/app/views/insights/pages/agents/components/tracesTable.tsx
@@ -450,7 +450,7 @@ function AgentTags({agents}: {agents: string[]}) {
   const resizeObserverRef = useRef<ResizeObserver | null>(null);
   const containerRef = useRef<HTMLDivElement>(null);
 
-  const handleShowAll = useCallback(() => {
+  const handleShowAll = () => {
     setShowAll(!showAll);
 
     if (!containerRef.current) return;
@@ -466,7 +466,7 @@ function AgentTags({agents}: {agents: string[]}) {
     });
     resizeObserverRef.current = observer;
     observer.observe(containerRef.current);
-  }, [showAll]);
+  };
 
   // Cleanup the resize observer when the component unmounts
   useEffect(() => {
diff --git a/static/app/views/insights/pages/conversations/components/conversationSummary.tsx b/static/app/views/insights/pages/conversations/components/conversationSummary.tsx
index ba169269d2796f..204a407626ca96 100644
--- a/static/app/views/insights/pages/conversations/components/conversationSummary.tsx
+++ b/static/app/views/insights/pages/conversations/components/conversationSummary.tsx
@@ -1,5 +1,5 @@
 import type React from 'react';
-import {useCallback, useMemo} from 'react';
+import {useMemo} from 'react';
 import {css} from '@emotion/react';
 import styled from '@emotion/styled';
 
@@ -100,11 +100,11 @@ export function ConversationSummary({
   const {selection} = usePageFilters();
   const aggregates = useMemo(() => calculateAggregates(nodes), [nodes]);
 
-  const handleCopyConversationId = useCallback(() => {
+  const handleCopyConversationId = () => {
     copyToClipboard(conversationId, {
       successMessage: t('Copied conversation ID to clipboard'),
     });
-  }, [conversationId]);
+  };
 
   const traces = useMemo(() => {
     if (!nodeTraceMap) {
diff --git a/static/app/views/insights/pages/conversations/components/conversationView.tsx b/static/app/views/insights/pages/conversations/components/conversationView.tsx
index 347581ad99a482..3e430500d9f9fd 100644
--- a/static/app/views/insights/pages/conversations/components/conversationView.tsx
+++ b/static/app/views/insights/pages/conversations/components/conversationView.tsx
@@ -124,19 +124,16 @@ function ConversationView({
   const organization = useOrganization();
   const [activeTab, setActiveTab] = useState<ConversationTab>('messages');
 
-  const handleTabChange = useCallback(
-    (newTab: ConversationTab) => {
-      if (activeTab !== newTab) {
-        trackAnalytics('conversations.drawer.tab-switch', {
-          organization,
-          fromTab: activeTab,
-          toTab: newTab,
-        });
-      }
-      setActiveTab(newTab);
-    },
-    [organization, activeTab]
-  );
+  const handleTabChange = (newTab: ConversationTab) => {
+    if (activeTab !== newTab) {
+      trackAnalytics('conversations.drawer.tab-switch', {
+        organization,
+        fromTab: activeTab,
+        toTab: newTab,
+      });
+    }
+    setActiveTab(newTab);
+  };
 
   if (isLoading) {
     return <ConversationViewSkeleton />;
diff --git a/static/app/views/issueDetails/actions/shareModal.tsx b/static/app/views/issueDetails/actions/shareModal.tsx
index 7262dfc04a477f..6df642178957bf 100644
--- a/static/app/views/issueDetails/actions/shareModal.tsx
+++ b/static/app/views/issueDetails/actions/shareModal.tsx
@@ -1,9 +1,9 @@
-import {Fragment, useCallback, useRef, useState} from 'react';
+import {Fragment, useRef, useState} from 'react';
 import styled from '@emotion/styled';
 
 import {Button} from '@sentry/scraps/button';
 import {Checkbox} from '@sentry/scraps/checkbox';
-import {Grid, Stack, type GridProps} from '@sentry/scraps/layout';
+import {Grid, type GridProps, Stack} from '@sentry/scraps/layout';
 import {Switch} from '@sentry/scraps/switch';
 
 import {bulkUpdate} from 'sentry/actionCreators/group';
@@ -79,45 +79,45 @@ export function ShareIssueModal({
 
   const {copy} = useCopyToClipboard();
 
-  const handleCopyIssueLink = useCallback(() => {
+  const handleCopyIssueLink = () => {
     copy(issueUrl, {successMessage: t('Copied Issue Link to clipboard')}).then(
       closeModal
     );
-  }, [copy, issueUrl, closeModal]);
+  };
 
-  const handleCopyMarkdownLink = useCallback(() => {
+  const handleCopyMarkdownLink = () => {
     copy(markdownLink, {successMessage: t('Copied Markdown link to clipboard')}).then(
       closeModal
     );
-  }, [copy, markdownLink, closeModal]);
+  };
 
-  const handlePublicShare = useCallback(
-    (e: React.ChangeEvent<HTMLInputElement> | null, reshare?: boolean) => {
-      e?.preventDefault();
-      setLoading(true);
-      onToggle();
-      bulkUpdate(
-        api,
-        {
-          orgId: organization.slug,
-          projectId: projectSlug,
-          itemIds: [groupId],
-          data: {
-            isPublic: reshare ?? !isPublished,
-          },
+  const handlePublicShare = (
+    e: React.ChangeEvent<HTMLInputElement> | null,
+    reshare?: boolean
+  ) => {
+    e?.preventDefault();
+    setLoading(true);
+    onToggle();
+    bulkUpdate(
+      api,
+      {
+        orgId: organization.slug,
+        projectId: projectSlug,
+        itemIds: [groupId],
+        data: {
+          isPublic: reshare ?? !isPublished,
         },
-        {
-          error: () => {
-            addErrorMessage(t('Error sharing'));
-          },
-          complete: () => {
-            setLoading(false);
-          },
-        }
-      );
-    },
-    [api, setLoading, onToggle, isPublished, organization.slug, projectSlug, groupId]
-  );
+      },
+      {
+        error: () => {
+          addErrorMessage(t('Error sharing'));
+        },
+        complete: () => {
+          setLoading(false);
+        },
+      }
+    );
+  };
 
   const shareUrl = group?.shareId ? getShareUrl(organization, group) : null;
 
diff --git a/static/app/views/issueDetails/groupSimilarIssues/similarStackTrace/item.tsx b/static/app/views/issueDetails/groupSimilarIssues/similarStackTrace/item.tsx
index 811fb44283ae72..f1144ff1ac138e 100644
--- a/static/app/views/issueDetails/groupSimilarIssues/similarStackTrace/item.tsx
+++ b/static/app/views/issueDetails/groupSimilarIssues/similarStackTrace/item.tsx
@@ -80,20 +80,17 @@ export function SimilarStackTraceItem(props: Props) {
     }
   }, [busy, issue.id]);
 
-  const handleShowDiff = useCallback(
-    (event: React.MouseEvent) => {
-      const {groupId: baseIssueId, project} = props;
-      const {id: targetIssueId} = issue;
-
-      openDiffModal({
-        baseIssueId,
-        targetIssueId,
-        project,
-      });
-      event.stopPropagation();
-    },
-    [issue, props]
-  );
+  const handleShowDiff = (event: React.MouseEvent) => {
+    const {groupId: baseIssueId, project} = props;
+    const {id: targetIssueId} = issue;
+
+    openDiffModal({
+      baseIssueId,
+      targetIssueId,
+      project,
+    });
+    event.stopPropagation();
+  };
 
   const similarInterfaces = hasSimilarityEmbeddingsFeature
     ? (['exception'] as const)
diff --git a/static/app/views/issueDetails/streamline/eventTitle.tsx b/static/app/views/issueDetails/streamline/eventTitle.tsx
index fc4e00936dac4f..49e9b54e411730 100644
--- a/static/app/views/issueDetails/streamline/eventTitle.tsx
+++ b/static/app/views/issueDetails/streamline/eventTitle.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback, type CSSProperties} from 'react';
+import {type CSSProperties, Fragment} from 'react';
 import {css, useTheme} from '@emotion/react';
 import styled from '@emotion/styled';
 // eslint-disable-next-line no-restricted-imports
@@ -68,7 +68,7 @@ export function EventTitle({event, group, ref, ...props}: EventNavigationProps)
 
   const {copy} = useCopyToClipboard();
 
-  const handleCopyEventId = useCallback(() => {
+  const handleCopyEventId = () => {
     copy(event.id, {successMessage: t('Event ID copied to clipboard')}).then(() => {
       trackAnalytics('issue_details.copy_event_id_clicked', {
         organization,
@@ -77,7 +77,7 @@ export function EventTitle({event, group, ref, ...props}: EventNavigationProps)
         streamline: true,
       });
     });
-  }, [copy, organization, group, event]);
+  };
 
   return (
     <div {...props} ref={ref}>
diff --git a/static/app/views/issueDetails/streamline/instrumentationFixSection.tsx b/static/app/views/issueDetails/streamline/instrumentationFixSection.tsx
index dd7c27b6f14ba1..4bb59c0f52d04f 100644
--- a/static/app/views/issueDetails/streamline/instrumentationFixSection.tsx
+++ b/static/app/views/issueDetails/streamline/instrumentationFixSection.tsx
@@ -67,9 +67,9 @@ export function InstrumentationFixSection({group}: InstrumentationFixSectionProp
     [blocks, artifacts]
   );
 
-  const handleStartCodeChanges = useCallback(() => {
+  const handleStartCodeChanges = () => {
     startStep('code_changes');
-  }, [startStep]);
+  };
 
   const handleStartStep = useCallback(
     async (step: Parameters<typeof startStep>[0]) => {
diff --git a/static/app/views/issueDetails/streamline/sidebar/activitySection.tsx b/static/app/views/issueDetails/streamline/sidebar/activitySection.tsx
index c82c71c105f451..c8327b5688fb6d 100644
--- a/static/app/views/issueDetails/streamline/sidebar/activitySection.tsx
+++ b/static/app/views/issueDetails/streamline/sidebar/activitySection.tsx
@@ -222,28 +222,25 @@ export function StreamlinedActivitySection({
     [group.activity, mutators, group.id, organization]
   );
 
-  const handleCreate = useCallback(
-    (n: NoteType, _me: User) => {
-      mutators.handleCreate(n, group.activity, {
-        onError: err => {
-          const errMessage = err.responseJSON?.detail
-            ? tct('Error: [msg]', {msg: err.responseJSON?.detail as string})
-            : t('Unable to post comment');
-          addErrorMessage(errMessage);
-        },
-        onSuccess: data => {
-          GroupStore.addActivity(group.id, data);
-          trackAnalytics('issue_details.comment_created', {
-            organization,
-            streamline: true,
-            org_streamline_only: organization.streamlineOnly ?? undefined,
-          });
-          addSuccessMessage(t('Comment posted'));
-        },
-      });
-    },
-    [group.activity, mutators, group.id, organization]
-  );
+  const handleCreate = (n: NoteType, _me: User) => {
+    mutators.handleCreate(n, group.activity, {
+      onError: err => {
+        const errMessage = err.responseJSON?.detail
+          ? tct('Error: [msg]', {msg: err.responseJSON?.detail as string})
+          : t('Unable to post comment');
+        addErrorMessage(errMessage);
+      },
+      onSuccess: data => {
+        GroupStore.addActivity(group.id, data);
+        trackAnalytics('issue_details.comment_created', {
+          organization,
+          streamline: true,
+          org_streamline_only: organization.streamlineOnly ?? undefined,
+        });
+        addSuccessMessage(t('Comment posted'));
+      },
+    });
+  };
 
   const activityLink = {
     pathname: `${baseUrl}${TabPaths[Tab.ACTIVITY]}`,
diff --git a/static/app/views/issueDetails/streamline/sidebar/autofixSection.tsx b/static/app/views/issueDetails/streamline/sidebar/autofixSection.tsx
index 2b53486b83a272..6405e188cd6964 100644
--- a/static/app/views/issueDetails/streamline/sidebar/autofixSection.tsx
+++ b/static/app/views/issueDetails/streamline/sidebar/autofixSection.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useMemo, type CSSProperties} from 'react';
+import {type CSSProperties, useMemo} from 'react';
 import styled from '@emotion/styled';
 
 import seerConfigConnectImg from 'sentry-images/spot/seer-config-connect-2.svg';
@@ -9,6 +9,7 @@ import {Container, Flex} from '@sentry/scraps/layout';
 import {Text} from '@sentry/scraps/text';
 
 import {
+  type AutofixSection,
   getOrderedAutofixSections,
   isCodeChangesArtifact,
   isCodeChangesSection,
@@ -20,7 +21,6 @@ import {
   isSolutionArtifact,
   isSolutionSection,
   useExplorerAutofix,
-  type AutofixSection,
 } from 'sentry/components/events/autofix/useExplorerAutofix';
 import {
   CodeChangesPreview,
@@ -259,10 +259,10 @@ function AutofixEmptyState({
   // extract startStep first here so we can depend on it directly as `autofix` itself is unstable.
   const startStep = autofix.startStep;
 
-  const handleStartRootCause = useCallback(() => {
+  const handleStartRootCause = () => {
     startStep('root_cause');
     openSeerDrawer();
-  }, [startStep, openSeerDrawer]);
+  };
 
   return (
     <Flex direction="column" gap="md">
diff --git a/static/app/views/issueDetails/streamline/sidebar/seerNotices.tsx b/static/app/views/issueDetails/streamline/sidebar/seerNotices.tsx
index 98f9b2fe23ba6c..328b6d0a854eb2 100644
--- a/static/app/views/issueDetails/streamline/sidebar/seerNotices.tsx
+++ b/static/app/views/issueDetails/streamline/sidebar/seerNotices.tsx
@@ -168,7 +168,7 @@ export function SeerNotices({groupId, hasGithubIntegration, project}: SeerNotice
     needsCursorIntegration,
   ];
 
-  const handleSetupCursorHandoff = useCallback(async () => {
+  const handleSetupCursorHandoff = async () => {
     if (!cursorIntegration?.id) {
       return;
     }
@@ -193,14 +193,7 @@ export function SeerNotices({groupId, hasGithubIntegration, project}: SeerNotice
         integration_id: parseInt(cursorIntegration.id, 10),
       },
     });
-  }, [
-    cursorIntegration,
-    project.seerScannerAutomation,
-    project.autofixAutomationTuning,
-    updateProjectAutomation,
-    updateProjectSeerPreferences,
-    preference?.repositories,
-  ]);
+  };
 
   const handleSkipCursorStep = useCallback(() => {
     setCursorStepSkipped(true);
diff --git a/static/app/views/issueList/supergroups/supergroupFeedback.tsx b/static/app/views/issueList/supergroups/supergroupFeedback.tsx
index 5af7397183ee43..16e24cc512619b 100644
--- a/static/app/views/issueList/supergroups/supergroupFeedback.tsx
+++ b/static/app/views/issueList/supergroups/supergroupFeedback.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useState} from 'react';
+import {useState} from 'react';
 import styled from '@emotion/styled';
 
 import {Button} from '@sentry/scraps/button';
@@ -19,19 +19,16 @@ export function SupergroupFeedback({supergroupId}: SupergroupFeedbackProps) {
   const organization = useOrganization();
   const user = useUser();
 
-  const handleFeedback = useCallback(
-    (isAccurate: boolean) => {
-      trackAnalytics('supergroup.feedback_submitted', {
-        choice_selected: isAccurate,
-        supergroup_id: supergroupId,
-        user_id: user.id,
-        organization,
-      });
+  const handleFeedback = (isAccurate: boolean) => {
+    trackAnalytics('supergroup.feedback_submitted', {
+      choice_selected: isAccurate,
+      supergroup_id: supergroupId,
+      user_id: user.id,
+      organization,
+    });
 
-      setFeedbackSubmitted(true);
-    },
-    [supergroupId, organization, user]
-  );
+    setFeedbackSubmitted(true);
+  };
 
   return (
     <FeedbackContainer>
diff --git a/static/app/views/navigation/mobileNavigation.tsx b/static/app/views/navigation/mobileNavigation.tsx
index 8473e51a1e330e..a7bd0e10122c8d 100644
--- a/static/app/views/navigation/mobileNavigation.tsx
+++ b/static/app/views/navigation/mobileNavigation.tsx
@@ -71,11 +71,8 @@ export function MobileNavigation() {
     }
   }, [endTour, layout, currentStepId]);
 
-  const handleClick = useCallback(
-    () =>
-      setView(v => (v === 'closed' ? (activeGroup ? 'secondary' : 'primary') : 'closed')),
-    [activeGroup]
-  );
+  const handleClick = () =>
+    setView(v => (v === 'closed' ? (activeGroup ? 'secondary' : 'primary') : 'closed'));
 
   const showSuperuserWarning =
     isActiveSuperuser() &&
diff --git a/static/app/views/onboarding/components/welcomeSkipButton.tsx b/static/app/views/onboarding/components/welcomeSkipButton.tsx
index c563a6bcd13024..121b217253d1f8 100644
--- a/static/app/views/onboarding/components/welcomeSkipButton.tsx
+++ b/static/app/views/onboarding/components/welcomeSkipButton.tsx
@@ -1,4 +1,4 @@
-import {useCallback, type PropsWithChildren} from 'react';
+import {type PropsWithChildren} from 'react';
 
 import {LinkButton} from '@sentry/scraps/button';
 import {Link} from '@sentry/scraps/link';
@@ -19,14 +19,14 @@ export function WelcomeSkipButton({
   const organization = useOrganization();
   const {activateSidebar} = useOnboardingSidebar();
 
-  const handleSkipOnboarding = useCallback(() => {
+  const handleSkipOnboarding = () => {
     trackAnalytics('growth.onboarding_clicked_skip', {
       organization,
       source: ONBOARDING_WELCOME_SCREEN_SOURCE,
     });
 
     activateSidebar({userClicked: false, source: 'targeted_onboarding_welcome_skip'});
-  }, [organization, activateSidebar]);
+  };
 
   const to = `/organizations/${organization.slug}/issues/?referrer=onboarding-welcome-skip`;
 
diff --git a/static/app/views/onboarding/onboarding.tsx b/static/app/views/onboarding/onboarding.tsx
index 13db1abf1ebda3..e82ec58a9b3860 100644
--- a/static/app/views/onboarding/onboarding.tsx
+++ b/static/app/views/onboarding/onboarding.tsx
@@ -271,28 +271,25 @@ export function OnboardingWithoutContext() {
     isRecentCreatedProjectActive: isProjectActive,
   });
 
-  const goNextStep = useCallback(
-    (
-      step: StepDescriptor,
-      platform?: OnboardingSelectedSDK,
-      query?: Record<string, string[]>
-    ) => {
-      const currentStepIndex = onboardingSteps.findIndex(s => s.id === step.id);
-      const nextStep = onboardingSteps[currentStepIndex + 1]!;
-
-      if (
-        nextStep.id === OnboardingStepId.SETUP_DOCS &&
-        !platform &&
-        !onboardingContext.selectedPlatform
-      ) {
-        return;
-      }
+  const goNextStep = (
+    step: StepDescriptor,
+    platform?: OnboardingSelectedSDK,
+    query?: Record<string, string[]>
+  ) => {
+    const currentStepIndex = onboardingSteps.findIndex(s => s.id === step.id);
+    const nextStep = onboardingSteps[currentStepIndex + 1]!;
 
-      const pathname = `/onboarding/${organization.slug}/${nextStep.id}/`;
-      navigate(query ? normalizeUrl({pathname, query}) : normalizeUrl(pathname));
-    },
-    [organization.slug, navigate, onboardingSteps, onboardingContext.selectedPlatform]
-  );
+    if (
+      nextStep.id === OnboardingStepId.SETUP_DOCS &&
+      !platform &&
+      !onboardingContext.selectedPlatform
+    ) {
+      return;
+    }
+
+    const pathname = `/onboarding/${organization.slug}/${nextStep.id}/`;
+    navigate(query ? normalizeUrl({pathname, query}) : normalizeUrl(pathname));
+  };
 
   const genSkipOnboardingLink = () => {
     const source = `targeted-onboarding-${stepId}`;
diff --git a/static/app/views/onboarding/scmPlatformFeatures.tsx b/static/app/views/onboarding/scmPlatformFeatures.tsx
index 36fb5446d434d0..a3f948f1d7168c 100644
--- a/static/app/views/onboarding/scmPlatformFeatures.tsx
+++ b/static/app/views/onboarding/scmPlatformFeatures.tsx
@@ -197,112 +197,97 @@ export function ScmPlatformFeatures({onComplete}: StepProps) {
     ]
   );
 
-  const applyPlatformSelection = useCallback(
-    (sdk: OnboardingSelectedSDK) => {
-      setSelectedPlatform(sdk);
-      setSelectedFeatures([ProductSolution.ERROR_MONITORING]);
-    },
-    [setSelectedPlatform, setSelectedFeatures]
-  );
+  const applyPlatformSelection = (sdk: OnboardingSelectedSDK) => {
+    setSelectedPlatform(sdk);
+    setSelectedFeatures([ProductSolution.ERROR_MONITORING]);
+  };
 
-  const handleManualPlatformSelect = useCallback(
-    async (option: {value: string}) => {
-      const platformKey = option.value as PlatformKey;
-      if (platformKey === selectedPlatform?.key) {
-        return;
-      }
+  const handleManualPlatformSelect = async (option: {value: string}) => {
+    const platformKey = option.value as PlatformKey;
+    if (platformKey === selectedPlatform?.key) {
+      return;
+    }
 
-      // Block disabled gaming/console platforms
-      const platformInfo = getPlatformInfo(platformKey);
-      if (
-        platformInfo &&
-        isDisabledGamingPlatform({
-          platform: platformInfo,
-          enabledConsolePlatforms: organization.enabledConsolePlatforms,
-        })
-      ) {
-        openConsoleModal({
-          organization,
-          selectedPlatform: toSelectedSdk(platformInfo),
-          origin: 'onboarding',
-        });
-        return;
-      }
+    // Block disabled gaming/console platforms
+    const platformInfo = getPlatformInfo(platformKey);
+    if (
+      platformInfo &&
+      isDisabledGamingPlatform({
+        platform: platformInfo,
+        enabledConsolePlatforms: organization.enabledConsolePlatforms,
+      })
+    ) {
+      openConsoleModal({
+        organization,
+        selectedPlatform: toSelectedSdk(platformInfo),
+        origin: 'onboarding',
+      });
+      return;
+    }
 
-      // For base languages (JavaScript, Python, etc.), show a modal suggesting
-      // specific frameworks — matching the legacy onboarding behavior.
-      if (platformInfo && shouldSuggestFramework(platformKey)) {
-        const baseSdk = toSelectedSdk(platformInfo);
-
-        const {FrameworkSuggestionModal, modalCss} =
-          await import('sentry/components/onboarding/frameworkSuggestionModal');
-
-        openModal(
-          deps => (
-            <FrameworkSuggestionModal
-              {...deps}
-              organization={organization}
-              selectedPlatform={baseSdk}
-              onConfigure={selectedFramework => {
-                applyPlatformSelection(selectedFramework);
-                trackAnalytics('onboarding.scm_platform_selected', {
-                  organization,
-                  platform: selectedFramework.key,
-                  source: 'manual',
-                });
-                closeModal();
-              }}
-              onSkip={() => {
-                applyPlatformSelection(baseSdk);
-                trackAnalytics('onboarding.scm_platform_selected', {
-                  organization,
-                  platform: platformKey,
-                  source: 'manual',
-                });
-                closeModal();
-              }}
-              newOrg
-            />
-          ),
-          {modalCss}
-        );
-        return;
-      }
+    // For base languages (JavaScript, Python, etc.), show a modal suggesting
+    // specific frameworks — matching the legacy onboarding behavior.
+    if (platformInfo && shouldSuggestFramework(platformKey)) {
+      const baseSdk = toSelectedSdk(platformInfo);
+
+      const {FrameworkSuggestionModal, modalCss} =
+        await import('sentry/components/onboarding/frameworkSuggestionModal');
+
+      openModal(
+        deps => (
+          <FrameworkSuggestionModal
+            {...deps}
+            organization={organization}
+            selectedPlatform={baseSdk}
+            onConfigure={selectedFramework => {
+              applyPlatformSelection(selectedFramework);
+              trackAnalytics('onboarding.scm_platform_selected', {
+                organization,
+                platform: selectedFramework.key,
+                source: 'manual',
+              });
+              closeModal();
+            }}
+            onSkip={() => {
+              applyPlatformSelection(baseSdk);
+              trackAnalytics('onboarding.scm_platform_selected', {
+                organization,
+                platform: platformKey,
+                source: 'manual',
+              });
+              closeModal();
+            }}
+            newOrg
+          />
+        ),
+        {modalCss}
+      );
+      return;
+    }
 
-      setPlatform(platformKey);
-      setSelectedFeatures([ProductSolution.ERROR_MONITORING]);
+    setPlatform(platformKey);
+    setSelectedFeatures([ProductSolution.ERROR_MONITORING]);
 
-      trackAnalytics('onboarding.scm_platform_selected', {
-        organization,
-        platform: platformKey,
-        source: 'manual',
-      });
-    },
-    [
-      selectedPlatform?.key,
-      setPlatform,
-      setSelectedFeatures,
-      applyPlatformSelection,
+    trackAnalytics('onboarding.scm_platform_selected', {
       organization,
-    ]
-  );
+      platform: platformKey,
+      source: 'manual',
+    });
+  };
 
-  const handleSelectDetectedPlatform = useCallback(
-    (platformKey: PlatformKey) => {
-      if (platformKey === selectedPlatform?.key) {
-        return;
-      }
-      setPlatform(platformKey);
-      setSelectedFeatures([ProductSolution.ERROR_MONITORING]);
+  const handleSelectDetectedPlatform = (platformKey: PlatformKey) => {
+    if (platformKey === selectedPlatform?.key) {
+      return;
+    }
+    setPlatform(platformKey);
+    setSelectedFeatures([ProductSolution.ERROR_MONITORING]);
 
-      trackAnalytics('onboarding.scm_platform_selected', {
-        organization,
-        platform: platformKey,
-        source: 'detected',
-      });
-    },
-    [selectedPlatform?.key, setPlatform, setSelectedFeatures, organization]
-  );
+    trackAnalytics('onboarding.scm_platform_selected', {
+      organization,
+      platform: platformKey,
+      source: 'detected',
+    });
+  };
 
   function handleChangePlatformClick() {
     setShowManualPicker(true);
diff --git a/static/app/views/performance/landing/metricsDataSwitcherAlert.tsx b/static/app/views/performance/landing/metricsDataSwitcherAlert.tsx
index 947a4465d6daf1..a9dfd77229cb0a 100644
--- a/static/app/views/performance/landing/metricsDataSwitcherAlert.tsx
+++ b/static/app/views/performance/landing/metricsDataSwitcherAlert.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useMemo} from 'react';
+import {useMemo} from 'react';
 
 import {Alert} from '@sentry/scraps/alert';
 import {ExternalLink, Link} from '@sentry/scraps/link';
@@ -63,9 +63,9 @@ export function MetricsDataSwitcherAlert(
     'performance-mep-bannerless-ui'
   );
 
-  const handleReviewUpdatesClick = useCallback(() => {
+  const handleReviewUpdatesClick = () => {
     OnboardingDrawerStore.open(OnboardingDrawerKey.BROADCASTS);
-  }, []);
+  };
 
   const docsLink = useMemo(() => {
     const platforms = getSelectedProjectPlatformsArray(location, props.projects);
@@ -89,9 +89,9 @@ export function MetricsDataSwitcherAlert(
     return `https://docs.sentry.io/platforms/${supportedPlatform}/enriching-events/transaction-name/`;
   }, [location, props.projects]);
 
-  const handleSwitchToCompatibleProjects = useCallback(() => {
+  const handleSwitchToCompatibleProjects = () => {
     updateProjects(props.compatibleProjects || [], location, navigate);
-  }, [props.compatibleProjects, location, navigate]);
+  };
 
   if (!props.shouldNotifyUnnamedTransactions && !props.shouldWarnIncompatibleSDK) {
     // Control showing generic sdk-alert here since stacking alerts is noisy.
diff --git a/static/app/views/performance/newTraceDetails/traceDrawer/tabs/traceAiSpans.tsx b/static/app/views/performance/newTraceDetails/traceDrawer/tabs/traceAiSpans.tsx
index 7672032d5d46bb..1978d5577c6947 100644
--- a/static/app/views/performance/newTraceDetails/traceDrawer/tabs/traceAiSpans.tsx
+++ b/static/app/views/performance/newTraceDetails/traceDrawer/tabs/traceAiSpans.tsx
@@ -69,11 +69,11 @@ export function TraceAiSpans({traceSlug}: {traceSlug: string}) {
     [location, navigate, organization]
   );
 
-  const handleViewFullTraceClick = useCallback(() => {
+  const handleViewFullTraceClick = () => {
     trackAnalytics('agent-monitoring.trace.view-full-trace-click', {
       organization,
     });
-  }, [organization]);
+  };
 
   if (isLoading) {
     return <LoadingIndicator />;
diff --git a/static/app/views/performance/newTraceDetails/traceDrawer/tabs/traceProfiles.tsx b/static/app/views/performance/newTraceDetails/traceDrawer/tabs/traceProfiles.tsx
index 89f3bc9504d62d..45465e4c7501c8 100644
--- a/static/app/views/performance/newTraceDetails/traceDrawer/tabs/traceProfiles.tsx
+++ b/static/app/views/performance/newTraceDetails/traceDrawer/tabs/traceProfiles.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback, useMemo} from 'react';
+import {Fragment, useMemo} from 'react';
 import styled from '@emotion/styled';
 import {PlatformIcon} from 'platformicons';
 
@@ -36,16 +36,13 @@ export function TraceProfiles({tree}: {tree: TraceTree}) {
     [tree.profiled_events]
   );
 
-  const onProfileLinkClick = useCallback(
-    (type: 'continuous' | 'transaction') => {
-      if (type === 'continuous') {
-        traceAnalytics.trackViewContinuousProfile(organization);
-      } else {
-        traceAnalytics.trackViewTransactionProfile(organization);
-      }
-    },
-    [organization]
-  );
+  const onProfileLinkClick = (type: 'continuous' | 'transaction') => {
+    if (type === 'continuous') {
+      traceAnalytics.trackViewContinuousProfile(organization);
+    } else {
+      traceAnalytics.trackViewTransactionProfile(organization);
+    }
+  };
 
   return (
     <ProfilesTable>
diff --git a/static/app/views/performance/newTraceDetails/traceRow/traceBar.tsx b/static/app/views/performance/newTraceDetails/traceRow/traceBar.tsx
index 4046c0ffa6224b..f6a1fc4e12c0d2 100644
--- a/static/app/views/performance/newTraceDetails/traceRow/traceBar.tsx
+++ b/static/app/views/performance/newTraceDetails/traceRow/traceBar.tsx
@@ -27,13 +27,10 @@ export function InvisibleTraceBar(props: InvisibleTraceBarProps) {
     [props.manager, props.node_space, props.virtualizedIndex]
   );
 
-  const onDoubleClick = useCallback(
-    (e: React.MouseEvent) => {
-      e.stopPropagation();
-      props.manager.onZoomIntoSpace(props.node_space!);
-    },
-    [props.manager, props.node_space]
-  );
+  const onDoubleClick = (e: React.MouseEvent) => {
+    e.stopPropagation();
+    props.manager.onZoomIntoSpace(props.node_space!);
+  };
 
   if (!props.node_space || !props.children) {
     return null;
diff --git a/static/app/views/performance/newTraceDetails/traceSearch/traceSearchInput.tsx b/static/app/views/performance/newTraceDetails/traceSearch/traceSearchInput.tsx
index a9dd9d6f75b2b0..baaa7eff5af951 100644
--- a/static/app/views/performance/newTraceDetails/traceSearch/traceSearchInput.tsx
+++ b/static/app/views/performance/newTraceDetails/traceSearch/traceSearchInput.tsx
@@ -86,29 +86,26 @@ export function TraceSearchInput(props: TraceSearchInputProps) {
     };
   }, [traceState.search.status]);
 
-  const onSearchFocus = useCallback(() => {
+  const onSearchFocus = () => {
     traceAnalytics.trackSearchFocus(organization);
     if (traceStateRef.current.rovingTabIndex.node) {
       traceDispatch({type: 'clear roving index'});
     }
-  }, [traceDispatch, organization]);
+  };
 
-  const onChange = useCallback(
-    (event: React.ChangeEvent<HTMLInputElement>) => {
-      if (!event.target.value) {
-        traceDispatch({type: 'clear query'});
-        return;
-      }
+  const onChange = (event: React.ChangeEvent<HTMLInputElement>) => {
+    if (!event.target.value) {
+      traceDispatch({type: 'clear query'});
+      return;
+    }
 
-      traceDispatch({type: 'set query', query: event.target.value});
-      onTraceSearch(
-        event.target.value,
-        traceStateRef.current.rovingTabIndex.node ?? traceStateRef.current.search.node,
-        'track result'
-      );
-    },
-    [traceDispatch, onTraceSearch]
-  );
+    traceDispatch({type: 'set query', query: event.target.value});
+    onTraceSearch(
+      event.target.value,
+      traceStateRef.current.rovingTabIndex.node ?? traceStateRef.current.search.node,
+      'track result'
+    );
+  };
 
   const onSearchClear = useCallback(() => {
     trackAnalytics('trace.trace_layout.search_clear', {
@@ -121,44 +118,41 @@ export function TraceSearchInput(props: TraceSearchInputProps) {
     }
   }, [traceDispatch, organization]);
 
-  const onKeyDown = useCallback(
-    (event: React.KeyboardEvent<HTMLInputElement>) => {
-      switch (event.key) {
-        case 'ArrowDown':
-          trackAnalytics('trace.trace_layout.search_match_navigate', {
-            organization,
-            direction: 'next',
-            interaction: 'arrowKey',
-          });
-          traceDispatch({
-            type: event.shiftKey ? 'go to last match' : 'go to next match',
-          });
-          break;
-        case 'ArrowUp':
-          trackAnalytics('trace.trace_layout.search_match_navigate', {
-            organization,
-            direction: 'prev',
-            interaction: 'arrowKey',
-          });
-          traceDispatch({
-            type: event.shiftKey ? 'go to first match' : 'go to previous match',
-          });
-          break;
-        case 'Enter':
-          trackAnalytics('trace.trace_layout.search_match_navigate', {
-            organization,
-            direction: event.shiftKey ? 'prev' : 'next',
-            interaction: 'enterKey',
-          });
-          traceDispatch({
-            type: event.shiftKey ? 'go to previous match' : 'go to next match',
-          });
-          break;
-        default:
-      }
-    },
-    [traceDispatch, organization]
-  );
+  const onKeyDown = (event: React.KeyboardEvent<HTMLInputElement>) => {
+    switch (event.key) {
+      case 'ArrowDown':
+        trackAnalytics('trace.trace_layout.search_match_navigate', {
+          organization,
+          direction: 'next',
+          interaction: 'arrowKey',
+        });
+        traceDispatch({
+          type: event.shiftKey ? 'go to last match' : 'go to next match',
+        });
+        break;
+      case 'ArrowUp':
+        trackAnalytics('trace.trace_layout.search_match_navigate', {
+          organization,
+          direction: 'prev',
+          interaction: 'arrowKey',
+        });
+        traceDispatch({
+          type: event.shiftKey ? 'go to first match' : 'go to previous match',
+        });
+        break;
+      case 'Enter':
+        trackAnalytics('trace.trace_layout.search_match_navigate', {
+          organization,
+          direction: event.shiftKey ? 'prev' : 'next',
+          interaction: 'enterKey',
+        });
+        traceDispatch({
+          type: event.shiftKey ? 'go to previous match' : 'go to next match',
+        });
+        break;
+      default:
+    }
+  };
 
   const onNextSearchClick = useCallback(() => {
     trackAnalytics('trace.trace_layout.search_match_navigate', {
diff --git a/static/app/views/performance/transactionSummary/pageLayout.tsx b/static/app/views/performance/transactionSummary/pageLayout.tsx
index 3761f50256a682..14f124c1e9bdc2 100644
--- a/static/app/views/performance/transactionSummary/pageLayout.tsx
+++ b/static/app/views/performance/transactionSummary/pageLayout.tsx
@@ -162,25 +162,22 @@ export function PageLayout(props: Props) {
     [location.query, organization, projectId, transactionName]
   );
 
-  const onTabChange = useCallback(
-    (newTab: Tab) => {
-      // Prevent infinite rerenders
-      if (newTab === tab) {
-        return;
-      }
+  const onTabChange = (newTab: Tab) => {
+    // Prevent infinite rerenders
+    if (newTab === tab) {
+      return;
+    }
 
-      const analyticsKey = TAB_ANALYTICS[newTab];
-      if (analyticsKey) {
-        trackAnalytics(analyticsKey, {
-          organization,
-          project_platforms: getSelectedProjectPlatforms(location, projects),
-        });
-      }
+    const analyticsKey = TAB_ANALYTICS[newTab];
+    if (analyticsKey) {
+      trackAnalytics(analyticsKey, {
+        organization,
+        project_platforms: getSelectedProjectPlatforms(location, projects),
+      });
+    }
 
-      navigate(normalizeUrl(getNewRoute(newTab)));
-    },
-    [getNewRoute, tab, organization, location, projects, navigate]
-  );
+    navigate(normalizeUrl(getNewRoute(newTab)));
+  };
 
   const shouldUseEAP = useTransactionSummaryEAP();
 
diff --git a/static/app/views/performance/transactionSummary/transactionProfiles/content.tsx b/static/app/views/performance/transactionSummary/transactionProfiles/content.tsx
index 04cdf3b07d2190..4b06c2cbca55eb 100644
--- a/static/app/views/performance/transactionSummary/transactionProfiles/content.tsx
+++ b/static/app/views/performance/transactionSummary/transactionProfiles/content.tsx
@@ -251,13 +251,13 @@ function AggregateFlamegraphToolbar(props: AggregateFlamegraphToolbarProps) {
       ];
     }, []);
 
-  const onResetZoom = useCallback(() => {
+  const onResetZoom = () => {
     props.scheduler.dispatch('reset zoom');
     trackAnalytics('profiling_views.aggregate_flamegraph.zoom.reset', {
       organization,
       profile_type: 'transaction aggregate flamegraph',
     });
-  }, [props.scheduler, organization]);
+  };
 
   const onFrameFilterChange = useCallback(
     (value: {value: 'application' | 'system' | 'all'}) => {
diff --git a/static/app/views/preprod/buildDetails/main/insights/appSizeInsights.tsx b/static/app/views/preprod/buildDetails/main/insights/appSizeInsights.tsx
index b3681591e9a072..3e4cd9fe809511 100644
--- a/static/app/views/preprod/buildDetails/main/insights/appSizeInsights.tsx
+++ b/static/app/views/preprod/buildDetails/main/insights/appSizeInsights.tsx
@@ -30,7 +30,7 @@ export function AppSizeInsights({
   const isSidebarOpen = searchParams.get('insights') === 'open';
   const organization = useOrganization();
 
-  const openSidebar = useCallback(() => {
+  const openSidebar = () => {
     trackAnalytics('preprod.builds.details.open_insights_sidebar', {
       organization,
       platform: platform ?? null,
@@ -40,7 +40,7 @@ export function AppSizeInsights({
     const newParams = new URLSearchParams(searchParams);
     newParams.set('insights', 'open');
     setSearchParams(newParams);
-  }, [organization, platform, projectType, searchParams, setSearchParams]);
+  };
 
   const closeSidebar = useCallback(() => {
     const newParams = new URLSearchParams(searchParams);
diff --git a/static/app/views/preprod/snapshots/header/snapshotHeaderActions.tsx b/static/app/views/preprod/snapshots/header/snapshotHeaderActions.tsx
index 44761cf64f2e87..4cd5423afc3927 100644
--- a/static/app/views/preprod/snapshots/header/snapshotHeaderActions.tsx
+++ b/static/app/views/preprod/snapshots/header/snapshotHeaderActions.tsx
@@ -65,7 +65,7 @@ export function SnapshotHeaderActions({
       : undefined,
   }));
 
-  const handleApprove = useCallback(() => {
+  const handleApprove = () => {
     setIsApproving(true);
     clientRef.current.request(
       `/organizations/${organizationSlug}/preprodartifacts/${data.head_artifact_id}/approve/`,
@@ -87,7 +87,7 @@ export function SnapshotHeaderActions({
         },
       }
     );
-  }, [organizationSlug, data.head_artifact_id, queryClient, apiUrl]);
+  };
 
   const handleRerunStatusChecks = useCallback(() => {
     clientRef.current.request(
diff --git a/static/app/views/profiling/content.tsx b/static/app/views/profiling/content.tsx
index be56ee07d4c622..df27aa1c1047d1 100644
--- a/static/app/views/profiling/content.tsx
+++ b/static/app/views/profiling/content.tsx
@@ -111,32 +111,29 @@ export default function ProfilingContent() {
 
   const tab = decodeTab(location.query.tab);
 
-  const onTabChange = useCallback(
-    (newTab: 'flamegraph' | 'transactions') => {
-      // make sure to reset the state of the tabs
-      dispatchDataState({
-        dataKey: 'flamegraphData',
-        dataState: 'pending',
-      });
-      dispatchDataState({
-        dataKey: 'transactionsTableData',
-        dataState: 'pending',
-      });
-
-      trackAnalytics('profiling_views.landing.tab_change', {
-        organization,
+  const onTabChange = (newTab: 'flamegraph' | 'transactions') => {
+    // make sure to reset the state of the tabs
+    dispatchDataState({
+      dataKey: 'flamegraphData',
+      dataState: 'pending',
+    });
+    dispatchDataState({
+      dataKey: 'transactionsTableData',
+      dataState: 'pending',
+    });
+
+    trackAnalytics('profiling_views.landing.tab_change', {
+      organization,
+      tab: newTab,
+    });
+    navigate({
+      ...location,
+      query: {
+        ...location.query,
         tab: newTab,
-      });
-      navigate({
-        ...location,
-        query: {
-          ...location.query,
-          tab: newTab,
-        },
-      });
-    },
-    [dispatchDataState, location, navigate, organization]
-  );
+      },
+    });
+  };
 
   const maxPickableDays = useMaxPickableDays({
     dataCategories: [DataCategory.PROFILE_DURATION, DataCategory.PROFILE_DURATION_UI],
diff --git a/static/app/views/profiling/landingAggregateFlamegraph.tsx b/static/app/views/profiling/landingAggregateFlamegraph.tsx
index 8dcceffb5b05b7..b93d7d3d918c32 100644
--- a/static/app/views/profiling/landingAggregateFlamegraph.tsx
+++ b/static/app/views/profiling/landingAggregateFlamegraph.tsx
@@ -88,13 +88,13 @@ function AggregateFlamegraphToolbar(props: AggregateFlamegraphToolbarProps) {
       ];
     }, []);
 
-  const onResetZoom = useCallback(() => {
+  const onResetZoom = () => {
     props.scheduler.dispatch('reset zoom');
     trackAnalytics('profiling_views.aggregate_flamegraph.zoom.reset', {
       organization,
       profile_type: 'landing aggregate flamegraph',
     });
-  }, [props.scheduler, organization]);
+  };
 
   const onFrameFilterChange = useCallback(
     (value: {value: 'application' | 'system' | 'all'}) => {
diff --git a/static/app/views/projectInstall/platform.tsx b/static/app/views/projectInstall/platform.tsx
index 9e8c7e5af66b23..ae57510ff8bf75 100644
--- a/static/app/views/projectInstall/platform.tsx
+++ b/static/app/views/projectInstall/platform.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback, useMemo} from 'react';
+import {Fragment, useMemo} from 'react';
 import styled from '@emotion/styled';
 import type {LocationDescriptorObject} from 'history';
 
@@ -48,27 +48,24 @@ export function ProjectInstallPlatform({project, platform}: Props) {
     [location.query.product]
   );
 
-  const redirectWithProjectSelection = useCallback(
-    (to: LocationDescriptorObject) => {
-      if (!project?.id) {
-        return;
-      }
-      // We need to persist and pin the project filter
-      // so the selection does not reset on further navigation
-      PageFiltersStore.updateProjects([Number(project?.id)], null);
-      PageFiltersStore.pin('projects', true);
-      setPageFiltersStorage(organization.slug, new Set(['projects']));
-
-      navigate({
-        ...to,
-        query: {
-          ...to.query,
-          project: project?.id,
-        },
-      });
-    },
-    [navigate, organization.slug, project?.id]
-  );
+  const redirectWithProjectSelection = (to: LocationDescriptorObject) => {
+    if (!project?.id) {
+      return;
+    }
+    // We need to persist and pin the project filter
+    // so the selection does not reset on further navigation
+    PageFiltersStore.updateProjects([Number(project?.id)], null);
+    PageFiltersStore.pin('projects', true);
+    setPageFiltersStorage(organization.slug, new Set(['projects']));
+
+    navigate({
+      ...to,
+      query: {
+        ...to.query,
+        project: project?.id,
+      },
+    });
+  };
 
   if (!platform) {
     return <NotFound />;
diff --git a/static/app/views/pullRequest/details/main/prFilesList.tsx b/static/app/views/pullRequest/details/main/prFilesList.tsx
index 685cde1127dc97..c0b7b015f2988e 100644
--- a/static/app/views/pullRequest/details/main/prFilesList.tsx
+++ b/static/app/views/pullRequest/details/main/prFilesList.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback, useEffect, useMemo, useState} from 'react';
+import {Fragment, useEffect, useMemo, useState} from 'react';
 import styled from '@emotion/styled';
 
 import {Container, Flex} from '@sentry/scraps/layout';
@@ -74,12 +74,12 @@ export function PRFilesList({files}: PRFilesListProps) {
     setExpandedFiles(initialExpanded);
   }, [files]);
 
-  const toggleFileExpanded = useCallback((filename: string) => {
+  const toggleFileExpanded = (filename: string) => {
     setExpandedFiles(prev => ({
       ...prev,
       [filename]: !prev[filename],
     }));
-  }, []);
+  };
 
   const totalStats = useMemo(() => {
     return files.reduce(
diff --git a/static/app/views/releases/list/releaseHealthCTA.tsx b/static/app/views/releases/list/releaseHealthCTA.tsx
index 687c6c5dd99f2a..4ccf701ad9d2b2 100644
--- a/static/app/views/releases/list/releaseHealthCTA.tsx
+++ b/static/app/views/releases/list/releaseHealthCTA.tsx
@@ -1,4 +1,3 @@
-import {useCallback} from 'react';
 import styled from '@emotion/styled';
 
 import {Alert} from '@sentry/scraps/alert';
@@ -46,14 +45,14 @@ export function ReleaseHealthCTA({
     }
   );
 
-  const trackAddReleaseHealth = useCallback(() => {
+  const trackAddReleaseHealth = () => {
     if (organization.id && selection.projects[0]) {
       trackAnalytics('releases_list.click_add_release_health', {
         organization,
         project_id: selection.projects[0],
       });
     }
-  }, [organization, selection]);
+  };
 
   if (isPending || isError) {
     return null;
diff --git a/static/app/views/releases/list/releasesPromo.tsx b/static/app/views/releases/list/releasesPromo.tsx
index 3ad3b624d36e0a..94a45c8b4f91a3 100644
--- a/static/app/views/releases/list/releasesPromo.tsx
+++ b/static/app/views/releases/list/releasesPromo.tsx
@@ -151,16 +151,13 @@ export function ReleasesPromo({organization, project}: Props) {
     });
   }, [organization, project]);
 
-  const trackQuickstartCreatedIntegration = useCallback(
-    (integration: SentryApp) => {
-      trackAnalytics('releases.quickstart_create_integration.success', {
-        organization,
-        project_id: project.id,
-        integration_uuid: integration.uuid,
-      });
-    },
-    [organization, project]
-  );
+  const trackQuickstartCreatedIntegration = (integration: SentryApp) => {
+    trackAnalytics('releases.quickstart_create_integration.success', {
+      organization,
+      project_id: project.id,
+      integration_uuid: integration.uuid,
+    });
+  };
 
   const trackCreateIntegrationModalClose = useCallback(() => {
     trackAnalytics('releases.quickstart_create_integration_modal.close', {
diff --git a/static/app/views/relocation/relocation.tsx b/static/app/views/relocation/relocation.tsx
index afe46982a4c20f..11e02f871b26e0 100644
--- a/static/app/views/relocation/relocation.tsx
+++ b/static/app/views/relocation/relocation.tsx
@@ -190,15 +190,12 @@ export function RelocationOnboarding() {
     navigate(normalizeUrl(`/relocation/${step.id}/`));
   };
 
-  const goNextStep = useCallback(
-    (step: StepDescriptor) => {
-      const currentStepIndex = onboardingSteps.findIndex(s => s.id === step.id);
-      const nextStep = onboardingSteps[currentStepIndex + 1]!;
+  const goNextStep = (step: StepDescriptor) => {
+    const currentStepIndex = onboardingSteps.findIndex(s => s.id === step.id);
+    const nextStep = onboardingSteps[currentStepIndex + 1]!;
 
-      navigate(normalizeUrl(`/relocation/${nextStep.id}/`));
-    },
-    [onboardingSteps, navigate]
-  );
+    navigate(normalizeUrl(`/relocation/${nextStep.id}/`));
+  };
 
   if (!stepObj || stepIndex === -1) {
     return <Redirect to={normalizeUrl(`/relocation/${onboardingSteps[0]!.id}/`)} />;
diff --git a/static/app/views/replays/detail/ai/chapterList.tsx b/static/app/views/replays/detail/ai/chapterList.tsx
index ad756072f163af..803aa1f62f03aa 100644
--- a/static/app/views/replays/detail/ai/chapterList.tsx
+++ b/static/app/views/replays/detail/ai/chapterList.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useMemo, useState} from 'react';
+import {useMemo, useState} from 'react';
 import styled from '@emotion/styled';
 import classNames from 'classnames';
 
@@ -30,13 +30,10 @@ interface Props {
 export function ChapterList({timeRanges}: Props) {
   const replay = useReplayReader();
   const {setCurrentTime} = useReplayContext();
-  const onClickChapterTimestamp = useCallback(
-    (event: React.MouseEvent<Element>, start: number) => {
-      event.stopPropagation();
-      setCurrentTime(start - (replay?.getStartTimestampMs() ?? 0));
-    },
-    [replay, setCurrentTime]
-  );
+  const onClickChapterTimestamp = (event: React.MouseEvent<Element>, start: number) => {
+    event.stopPropagation();
+    setCurrentTime(start - (replay?.getStartTimestampMs() ?? 0));
+  };
 
   // do not include chapters that are before the start of the replay;
   // we filter these crumbs on the frontend anyway
diff --git a/static/app/views/replays/list/saveReplayQueryButton.tsx b/static/app/views/replays/list/saveReplayQueryButton.tsx
index 3ff4874a186e02..a36817fc19c438 100644
--- a/static/app/views/replays/list/saveReplayQueryButton.tsx
+++ b/static/app/views/replays/list/saveReplayQueryButton.tsx
@@ -1,5 +1,3 @@
-import {useCallback} from 'react';
-
 import {Button} from '@sentry/scraps/button';
 
 import {openSaveQueryModal} from 'sentry/actionCreators/modal';
@@ -12,13 +10,13 @@ export function SaveReplayQueryButton() {
   const organization = useOrganization();
   const {saveQuery} = useReplaySaveQuery();
 
-  const handleClick = useCallback(() => {
+  const handleClick = () => {
     openSaveQueryModal({
       organization,
       saveQuery,
       traceItemDataset: TraceItemDataset.REPLAYS,
     });
-  }, [organization, saveQuery]);
+  };
 
   return <Button onClick={handleClick}>{t('Save as')}</Button>;
 }
diff --git a/static/app/views/seerExplorer/blockComponents.tsx b/static/app/views/seerExplorer/blockComponents.tsx
index 2bb1f6db1493f6..caff48a5cc3318 100644
--- a/static/app/views/seerExplorer/blockComponents.tsx
+++ b/static/app/views/seerExplorer/blockComponents.tsx
@@ -287,33 +287,23 @@ export function BlockComponent({
     false
   );
 
-  const trackThumbsFeedback = useCallback(
-    (type: 'positive' | 'negative') => {
-      // Guard against missing runId (shouldn't happen with showActions check, but be defensive)
-      // Do this instead of hiding buttons to prevent flickering while data's loading for this edge case.
-      if (!feedbackSubmitted && runId !== undefined) {
-        trackAnalytics('seer.explorer.feedback_submitted', {
-          organization,
-          type,
-          run_id: runId,
-          block_index: blockIndex,
-          block_message: block.message.content.slice(0, 100),
-          langfuse_url: getLangfuseUrl(runId),
-          explorer_url: getExplorerUrl(runId),
-          conversations_url: getConversationsUrl('sentry', runId),
-        });
-        setFeedbackSubmitted(true); // disable button for rest of the session
-      }
-    },
-    [
-      organization,
-      blockIndex,
-      runId,
-      block.message.content,
-      feedbackSubmitted,
-      setFeedbackSubmitted,
-    ]
-  );
+  const trackThumbsFeedback = (type: 'positive' | 'negative') => {
+    // Guard against missing runId (shouldn't happen with showActions check, but be defensive)
+    // Do this instead of hiding buttons to prevent flickering while data's loading for this edge case.
+    if (!feedbackSubmitted && runId !== undefined) {
+      trackAnalytics('seer.explorer.feedback_submitted', {
+        organization,
+        type,
+        run_id: runId,
+        block_index: blockIndex,
+        block_message: block.message.content.slice(0, 100),
+        langfuse_url: getLangfuseUrl(runId),
+        explorer_url: getExplorerUrl(runId),
+        conversations_url: getConversationsUrl('sentry', runId),
+      });
+      setFeedbackSubmitted(true); // disable button for rest of the session
+    }
+  };
 
   const thumbsFeedbackButton = (type: 'positive' | 'negative') => {
     const ariaLabel =
diff --git a/static/app/views/settings/components/dataScrubbing/modals/dataScrubFormModal.tsx b/static/app/views/settings/components/dataScrubbing/modals/dataScrubFormModal.tsx
index 25d9ee24af70e4..fdf7f8259a08b3 100644
--- a/static/app/views/settings/components/dataScrubbing/modals/dataScrubFormModal.tsx
+++ b/static/app/views/settings/components/dataScrubbing/modals/dataScrubFormModal.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback, useState} from 'react';
+import {Fragment, useState} from 'react';
 import {css} from '@emotion/react';
 import styled from '@emotion/styled';
 import sortBy from 'lodash/sortBy';
@@ -163,23 +163,20 @@ export function DataScrubFormModal({
 
   const type = useStore(form.store, state => state.values.type);
 
-  const handleValidateAttributeField = useCallback(
-    (value: string) => {
-      const traceItemField = TraceItemFieldSelector.fromField(dataset, value);
+  const handleValidateAttributeField = (value: string) => {
+    const traceItemField = TraceItemFieldSelector.fromField(dataset, value);
 
-      if (!traceItemField) {
-        return;
-      }
+    if (!traceItemField) {
+      return;
+    }
 
-      const validation = validateTraceItemFieldSelector(traceItemField);
-      if (!validation.isValid && validation.error) {
-        setFieldErrors(form, {
-          source: {message: validation.error},
-        });
-      }
-    },
-    [dataset, form]
-  );
+    const validation = validateTraceItemFieldSelector(traceItemField);
+    if (!validation.isValid && validation.error) {
+      setFieldErrors(form, {
+        source: {message: validation.error},
+      });
+    }
+  };
 
   const containsRootDeepWildcard = (source: string) => {
     return /(^|[^.])\*\*$/.test(source);
diff --git a/static/app/views/settings/components/settingsBreadcrumb/breadcrumbDropdown.tsx b/static/app/views/settings/components/settingsBreadcrumb/breadcrumbDropdown.tsx
index 24ac941feb4277..f02ea1b382379b 100644
--- a/static/app/views/settings/components/settingsBreadcrumb/breadcrumbDropdown.tsx
+++ b/static/app/views/settings/components/settingsBreadcrumb/breadcrumbDropdown.tsx
@@ -112,11 +112,11 @@ function MenuCrumb({crumbLabel, menuHasHover, isLast, ...props}: MenuCrumbProps)
     closeTimeoutRef.current = window.setTimeout(() => close?.(), CLOSE_MENU_TIMEOUT);
   }, [close]);
 
-  const handleOpen = useCallback(() => {
+  const handleOpen = () => {
     activeCrumbStates.forEach(state => state?.close());
     window.clearTimeout(closeTimeoutRef.current);
     open?.();
-  }, [open]);
+  };
 
   useEffect(() => {
     if (menuHasHover) {
diff --git a/static/app/views/settings/featureFlags/changeTracking/newProviderForm.tsx b/static/app/views/settings/featureFlags/changeTracking/newProviderForm.tsx
index 429af805dbe652..93883d2592f99a 100644
--- a/static/app/views/settings/featureFlags/changeTracking/newProviderForm.tsx
+++ b/static/app/views/settings/featureFlags/changeTracking/newProviderForm.tsx
@@ -1,4 +1,3 @@
-import {useCallback} from 'react';
 import {z} from 'zod';
 
 import {Button} from '@sentry/scraps/button';
@@ -68,11 +67,11 @@ export function NewProviderForm({
   const queryClient = useQueryClient();
   const navigate = useNavigate();
 
-  const handleGoBack = useCallback(() => {
+  const handleGoBack = () => {
     navigate(
       normalizeUrl(`/settings/${organization.slug}/feature-flags/change-tracking/`)
     );
-  }, [organization.slug, navigate]);
+  };
 
   const mutation = useMutation({
     mutationFn: ({provider, secret}: CreateSecretData) => {
diff --git a/static/app/views/settings/organizationAuthTokens/newAuthToken.tsx b/static/app/views/settings/organizationAuthTokens/newAuthToken.tsx
index 64af028cdc9004..31bc016641e4eb 100644
--- a/static/app/views/settings/organizationAuthTokens/newAuthToken.tsx
+++ b/static/app/views/settings/organizationAuthTokens/newAuthToken.tsx
@@ -1,4 +1,3 @@
-import {useCallback} from 'react';
 import styled from '@emotion/styled';
 import {z} from 'zod';
 
@@ -43,10 +42,7 @@ function AuthTokenCreateForm({
   const navigate = useNavigate();
   const queryClient = useQueryClient();
 
-  const handleGoBack = useCallback(
-    () => navigate(`/settings/${organization.slug}/auth-tokens/`),
-    [navigate, organization.slug]
-  );
+  const handleGoBack = () => navigate(`/settings/${organization.slug}/auth-tokens/`);
 
   const mutation = useMutation<
     OrgAuthTokenWithToken,
@@ -132,10 +128,7 @@ export default function OrganizationAuthTokensNewAuthToken() {
   const organization = useOrganization();
   const navigate = useNavigate();
 
-  const handleGoBack = useCallback(
-    () => navigate(`/settings/${organization.slug}/auth-tokens/`),
-    [navigate, organization.slug]
-  );
+  const handleGoBack = () => navigate(`/settings/${organization.slug}/auth-tokens/`);
 
   return (
     <div>
diff --git a/static/app/views/settings/organizationDeveloperSettings/sentryApplicationDashboard/requestLog.tsx b/static/app/views/settings/organizationDeveloperSettings/sentryApplicationDashboard/requestLog.tsx
index 4af52bd6160e7a..23f1f4b59a4356 100644
--- a/static/app/views/settings/organizationDeveloperSettings/sentryApplicationDashboard/requestLog.tsx
+++ b/static/app/views/settings/organizationDeveloperSettings/sentryApplicationDashboard/requestLog.tsx
@@ -170,14 +170,11 @@ export function RequestLog({app}: RequestLogProps) {
 
   const hasPrevPage = useMemo(() => currentPage > 0, [currentPage]);
 
-  const handleChangeEventType = useCallback(
-    (newEventType: string) => {
-      setEventType(newEventType);
-      setCurrentPage(0);
-      refetch();
-    },
-    [refetch]
-  );
+  const handleChangeEventType = (newEventType: string) => {
+    setEventType(newEventType);
+    setCurrentPage(0);
+    refetch();
+  };
 
   const handleChangeErrorsOnly = useCallback(() => {
     setErrorsOnly(!errorsOnly);
@@ -185,13 +182,13 @@ export function RequestLog({app}: RequestLogProps) {
     refetch();
   }, [errorsOnly, refetch]);
 
-  const handleNextPage = useCallback(() => {
+  const handleNextPage = () => {
     setCurrentPage(currentPage + 1);
-  }, [currentPage]);
+  };
 
-  const handlePrevPage = useCallback(() => {
+  const handlePrevPage = () => {
     setCurrentPage(currentPage - 1);
-  }, [currentPage]);
+  };
 
   return (
     <Fragment>
diff --git a/static/app/views/settings/organizationIntegrations/SplitInstallationIdModal.tsx b/static/app/views/settings/organizationIntegrations/SplitInstallationIdModal.tsx
index 4c33c1f700ec29..6f9d1ffe39707c 100644
--- a/static/app/views/settings/organizationIntegrations/SplitInstallationIdModal.tsx
+++ b/static/app/views/settings/organizationIntegrations/SplitInstallationIdModal.tsx
@@ -30,7 +30,7 @@ export function SplitInstallationIdModal(props: Props) {
     await navigator.clipboard.writeText(props.installationId);
   }, [props.installationId]);
 
-  const handleContinue = useCallback(() => {
+  const handleContinue = () => {
     onCopy();
     addSuccessMessage('Copied to clipboard');
 
@@ -39,7 +39,7 @@ export function SplitInstallationIdModal(props: Props) {
     openAdminIntegrationTimeoutRef.current = window.setTimeout(() => {
       window.open('https://app.split.io/org/admin/integrations');
     }, 2000);
-  }, [onCopy]);
+  };
 
   // no need to translate this temporary component
   return (
diff --git a/static/app/views/settings/organizationRelay/relayWrapper.tsx b/static/app/views/settings/organizationRelay/relayWrapper.tsx
index efdbc53e09a774..e9393c5a677dda 100644
--- a/static/app/views/settings/organizationRelay/relayWrapper.tsx
+++ b/static/app/views/settings/organizationRelay/relayWrapper.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useState} from 'react';
+import {useState} from 'react';
 import omit from 'lodash/omit';
 import {z} from 'zod';
 
@@ -42,7 +42,7 @@ export function RelayWrapper() {
 
   const disabled = !organization.access.includes('org:write');
 
-  const handleOpenAddDialog = useCallback(() => {
+  const handleOpenAddDialog = () => {
     openModal(modalProps => (
       <Add
         {...modalProps}
@@ -55,7 +55,7 @@ export function RelayWrapper() {
         }}
       />
     ));
-  }, [relays, api, organization.slug]);
+  };
 
   return (
     <SentryDocumentTitle title={t('Relay')} orgSlug={organization.slug}>
@@ -172,50 +172,44 @@ function RelayUsageList({
     }
   );
 
-  const handleOpenEditDialog = useCallback(
-    (publicKey: string) => {
-      const editRelay = relays.find(relay => relay.publicKey === publicKey);
+  const handleOpenEditDialog = (publicKey: string) => {
+    const editRelay = relays.find(relay => relay.publicKey === publicKey);
 
-      if (!editRelay) {
-        return;
-      }
-
-      openModal(modalProps => (
-        <Edit
-          {...modalProps}
-          savedRelays={relays}
-          api={api}
-          orgSlug={orgSlug}
-          relay={editRelay}
-          onSubmitSuccess={response => {
-            addSuccessMessage(t('Successfully updated Relay public key'));
-            onRelaysChange(response.trustedRelays);
-          }}
-        />
-      ));
-    },
-    [orgSlug, relays, api, onRelaysChange]
-  );
+    if (!editRelay) {
+      return;
+    }
 
-  const handleDeleteRelay = useCallback(
-    async (publicKey: string) => {
-      const trustedRelays = relays
-        .filter(relay => relay.publicKey !== publicKey)
-        .map(relay => omit(relay, ['created', 'lastModified']));
-
-      try {
-        const response = await api.requestPromise(`/organizations/${orgSlug}/`, {
-          method: 'PUT',
-          data: {trustedRelays},
-        });
-        addSuccessMessage(t('Successfully deleted Relay public key'));
-        onRelaysChange(response.trustedRelays);
-      } catch {
-        addErrorMessage(t('An unknown error occurred while deleting Relay public key'));
-      }
-    },
-    [relays, api, orgSlug, onRelaysChange]
-  );
+    openModal(modalProps => (
+      <Edit
+        {...modalProps}
+        savedRelays={relays}
+        api={api}
+        orgSlug={orgSlug}
+        relay={editRelay}
+        onSubmitSuccess={response => {
+          addSuccessMessage(t('Successfully updated Relay public key'));
+          onRelaysChange(response.trustedRelays);
+        }}
+      />
+    ));
+  };
+
+  const handleDeleteRelay = async (publicKey: string) => {
+    const trustedRelays = relays
+      .filter(relay => relay.publicKey !== publicKey)
+      .map(relay => omit(relay, ['created', 'lastModified']));
+
+    try {
+      const response = await api.requestPromise(`/organizations/${orgSlug}/`, {
+        method: 'PUT',
+        data: {trustedRelays},
+      });
+      addSuccessMessage(t('Successfully deleted Relay public key'));
+      onRelaysChange(response.trustedRelays);
+    } catch {
+      addErrorMessage(t('An unknown error occurred while deleting Relay public key'));
+    }
+  };
 
   if (isPending) {
     return <LoadingIndicator />;
diff --git a/static/app/views/settings/project/preprod/statusCheckRuleForm.tsx b/static/app/views/settings/project/preprod/statusCheckRuleForm.tsx
index 6f774b6b63230e..44f41bdf81483a 100644
--- a/static/app/views/settings/project/preprod/statusCheckRuleForm.tsx
+++ b/static/app/views/settings/project/preprod/statusCheckRuleForm.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useState} from 'react';
+import {useState} from 'react';
 import styled from '@emotion/styled';
 
 import {Button} from '@sentry/scraps/button';
@@ -65,9 +65,9 @@ export function StatusCheckRuleForm({rule, onSave, onDelete}: Props) {
     });
   };
 
-  const handleQueryChange = useCallback((query: string) => {
+  const handleQueryChange = (query: string) => {
     setFilterQuery(query);
-  }, []);
+  };
 
   const handleDelete = () => {
     const ruleDisplayValue =
diff --git a/static/app/views/settings/project/preprod/statusCheckRules.tsx b/static/app/views/settings/project/preprod/statusCheckRules.tsx
index 6e9eeaf8b55474..ebcd69a984ca23 100644
--- a/static/app/views/settings/project/preprod/statusCheckRules.tsx
+++ b/static/app/views/settings/project/preprod/statusCheckRules.tsx
@@ -71,21 +71,18 @@ export function StatusCheckRules() {
     [location.query, navigate]
   );
 
-  const handleToggleExpanded = useCallback(
-    (ruleId: string, isExpanded: boolean) => {
-      const newExpanded = new Set(expandedRuleIds);
-      if (isExpanded) {
-        newExpanded.add(ruleId);
-      } else {
-        newExpanded.delete(ruleId);
-        if (ruleId === newRuleId) {
-          setNewRuleId(null);
-        }
+  const handleToggleExpanded = (ruleId: string, isExpanded: boolean) => {
+    const newExpanded = new Set(expandedRuleIds);
+    if (isExpanded) {
+      newExpanded.add(ruleId);
+    } else {
+      newExpanded.delete(ruleId);
+      if (ruleId === newRuleId) {
+        setNewRuleId(null);
       }
-      updateExpandedInUrl([...newExpanded]);
-    },
-    [expandedRuleIds, newRuleId, updateExpandedInUrl]
-  );
+    }
+    updateExpandedInUrl([...newExpanded]);
+  };
 
   const hasRepositories = !isLoadingRepos && repositories && repositories.length > 0;
 
diff --git a/static/app/views/settings/project/projectFilters/projectFiltersSettings.tsx b/static/app/views/settings/project/projectFilters/projectFiltersSettings.tsx
index 7e527f79d2ea12..48a2bb35100242 100644
--- a/static/app/views/settings/project/projectFilters/projectFiltersSettings.tsx
+++ b/static/app/views/settings/project/projectFilters/projectFiltersSettings.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback, useState} from 'react';
+import {Fragment, useState} from 'react';
 import {css} from '@emotion/react';
 import styled from '@emotion/styled';
 import iconAndroid from 'sentry-logos/logo-android.svg';
@@ -415,23 +415,20 @@ export function ProjectFiltersSettings({project, params, features}: Props) {
 
   const filterList = filterListData ?? [];
 
-  const handleLegacyChange = useCallback(
-    ({
-      onChange,
-      onBlur,
-      event,
-      subfilters,
-    }: {
-      event: React.ChangeEvent | React.MouseEvent;
-      onBlur: FormFieldProps['onBlur'];
-      onChange: FormFieldProps['onChange'];
-      subfilters: Set<string>;
-    }) => {
-      onChange?.(subfilters, event);
-      onBlur?.(subfilters, event);
-    },
-    []
-  );
+  const handleLegacyChange = ({
+    onChange,
+    onBlur,
+    event,
+    subfilters,
+  }: {
+    event: React.ChangeEvent | React.MouseEvent;
+    onBlur: FormFieldProps['onBlur'];
+    onChange: FormFieldProps['onChange'];
+    subfilters: Set<string>;
+  }) => {
+    onChange?.(subfilters, event);
+    onBlur?.(subfilters, event);
+  };
 
   if (isPending) {
     return <LoadingIndicator />;
diff --git a/static/app/views/settings/project/projectKeys/details/keySettings.tsx b/static/app/views/settings/project/projectKeys/details/keySettings.tsx
index 58200b1ab90f14..23a4056de174c8 100644
--- a/static/app/views/settings/project/projectKeys/details/keySettings.tsx
+++ b/static/app/views/settings/project/projectKeys/details/keySettings.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback} from 'react';
+import {Fragment} from 'react';
 
 import {Button} from '@sentry/scraps/button';
 
@@ -51,7 +51,7 @@ export function KeySettings({
   const {keyId, projectId} = params;
   const apiEndpoint = `/projects/${organization.slug}/${projectId}/keys/${keyId}/`;
 
-  const handleRemove = useCallback(async () => {
+  const handleRemove = async () => {
     addLoadingMessage(t('Revoking key\u2026'));
 
     try {
@@ -67,7 +67,7 @@ export function KeySettings({
     } catch (_err) {
       addErrorMessage(t('Unable to revoke key'));
     }
-  }, [organization, api, onRemove, keyId, projectId]);
+  };
 
   const showOtlpTraces = organization.features.includes('relay-otlp-traces-endpoint');
   const showOtlpLogs = organization.features.includes('relay-otel-logs-endpoint');
diff --git a/static/app/views/settings/project/projectKeys/details/loaderSettings.tsx b/static/app/views/settings/project/projectKeys/details/loaderSettings.tsx
index 8cedf6fe164059..7cfd910e18e6ec 100644
--- a/static/app/views/settings/project/projectKeys/details/loaderSettings.tsx
+++ b/static/app/views/settings/project/projectKeys/details/loaderSettings.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback, useState} from 'react';
+import {Fragment, useState} from 'react';
 
 import {ExternalLink} from '@sentry/scraps/link';
 
@@ -63,88 +63,74 @@ export function LoaderSettings({keyId, orgSlug, project, data, updateData}: Prop
   const apiEndpoint = `/projects/${orgSlug}/${project.slug}/keys/${keyId}/`;
   const loaderLink = data.dsn.cdn;
 
-  const updateLoaderOption = useCallback(
-    async (changes: {
-      browserSdkVersion?: string;
-      hasDebug?: boolean;
-      hasFeedback?: boolean;
-      hasLogsAndMetrics?: boolean;
-      hasPerformance?: boolean;
-      hasReplay?: boolean;
-    }) => {
-      setRequestPending(true);
-      setOptimisticState({
-        browserSdkVersion: data.browserSdkVersion,
-        hasDebug: data.dynamicSdkLoaderOptions.hasDebug,
-        hasLogsAndMetrics: data.dynamicSdkLoaderOptions.hasLogsAndMetrics,
-        hasFeedback: data.dynamicSdkLoaderOptions.hasFeedback,
-        hasPerformance: data.dynamicSdkLoaderOptions.hasPerformance,
-        hasReplay: data.dynamicSdkLoaderOptions.hasReplay,
-        ...changes,
-      });
-      addLoadingMessage();
+  const updateLoaderOption = async (changes: {
+    browserSdkVersion?: string;
+    hasDebug?: boolean;
+    hasFeedback?: boolean;
+    hasLogsAndMetrics?: boolean;
+    hasPerformance?: boolean;
+    hasReplay?: boolean;
+  }) => {
+    setRequestPending(true);
+    setOptimisticState({
+      browserSdkVersion: data.browserSdkVersion,
+      hasDebug: data.dynamicSdkLoaderOptions.hasDebug,
+      hasLogsAndMetrics: data.dynamicSdkLoaderOptions.hasLogsAndMetrics,
+      hasFeedback: data.dynamicSdkLoaderOptions.hasFeedback,
+      hasPerformance: data.dynamicSdkLoaderOptions.hasPerformance,
+      hasReplay: data.dynamicSdkLoaderOptions.hasReplay,
+      ...changes,
+    });
+    addLoadingMessage();
 
-      const browserSdkVersion = changes.browserSdkVersion ?? data.browserSdkVersion;
+    const browserSdkVersion = changes.browserSdkVersion ?? data.browserSdkVersion;
 
-      let payload: any;
-      if (sdkVersionSupportsPerformanceAndReplay(browserSdkVersion)) {
-        payload = {
-          browserSdkVersion,
-          dynamicSdkLoaderOptions: {
-            hasDebug: changes.hasDebug ?? data.dynamicSdkLoaderOptions.hasDebug,
-            hasLogsAndMetrics: sdkVersionSupportsLogsAndMetrics(browserSdkVersion)
-              ? (changes.hasLogsAndMetrics ??
-                data.dynamicSdkLoaderOptions.hasLogsAndMetrics)
-              : false,
-            hasFeedback: changes.hasFeedback ?? data.dynamicSdkLoaderOptions.hasFeedback,
-            hasPerformance:
-              changes.hasPerformance ?? data.dynamicSdkLoaderOptions.hasPerformance,
-            hasReplay: changes.hasReplay ?? data.dynamicSdkLoaderOptions.hasReplay,
-          },
-        };
-      } else {
-        payload = {
-          browserSdkVersion,
-          dynamicSdkLoaderOptions: {
-            hasDebug: changes.hasDebug ?? data.dynamicSdkLoaderOptions.hasDebug,
-            hasLogsAndMetrics: false,
-            hasFeedback: false,
-            hasPerformance: false,
-            hasReplay: false,
-          },
-        };
-      }
+    let payload: any;
+    if (sdkVersionSupportsPerformanceAndReplay(browserSdkVersion)) {
+      payload = {
+        browserSdkVersion,
+        dynamicSdkLoaderOptions: {
+          hasDebug: changes.hasDebug ?? data.dynamicSdkLoaderOptions.hasDebug,
+          hasLogsAndMetrics: sdkVersionSupportsLogsAndMetrics(browserSdkVersion)
+            ? (changes.hasLogsAndMetrics ??
+              data.dynamicSdkLoaderOptions.hasLogsAndMetrics)
+            : false,
+          hasFeedback: changes.hasFeedback ?? data.dynamicSdkLoaderOptions.hasFeedback,
+          hasPerformance:
+            changes.hasPerformance ?? data.dynamicSdkLoaderOptions.hasPerformance,
+          hasReplay: changes.hasReplay ?? data.dynamicSdkLoaderOptions.hasReplay,
+        },
+      };
+    } else {
+      payload = {
+        browserSdkVersion,
+        dynamicSdkLoaderOptions: {
+          hasDebug: changes.hasDebug ?? data.dynamicSdkLoaderOptions.hasDebug,
+          hasLogsAndMetrics: false,
+          hasFeedback: false,
+          hasPerformance: false,
+          hasReplay: false,
+        },
+      };
+    }
 
-      try {
-        const response = await api.requestPromise(apiEndpoint, {
-          method: 'PUT',
-          data: payload,
-        });
+    try {
+      const response = await api.requestPromise(apiEndpoint, {
+        method: 'PUT',
+        data: payload,
+      });
 
-        updateData(response);
+      updateData(response);
 
-        addSuccessMessage(t('Successfully updated dynamic SDK loader configuration'));
-      } catch (error) {
-        const message = t('Unable to updated dynamic SDK loader configuration');
-        handleXhrErrorResponse(message, error as RequestError);
-        addErrorMessage(message);
-      } finally {
-        setRequestPending(false);
-      }
-    },
-    [
-      api,
-      apiEndpoint,
-      data.browserSdkVersion,
-      data.dynamicSdkLoaderOptions.hasDebug,
-      data.dynamicSdkLoaderOptions.hasLogsAndMetrics,
-      data.dynamicSdkLoaderOptions.hasFeedback,
-      data.dynamicSdkLoaderOptions.hasPerformance,
-      data.dynamicSdkLoaderOptions.hasReplay,
-      setRequestPending,
-      updateData,
-    ]
-  );
+      addSuccessMessage(t('Successfully updated dynamic SDK loader configuration'));
+    } catch (error) {
+      const message = t('Unable to updated dynamic SDK loader configuration');
+      handleXhrErrorResponse(message, error as RequestError);
+      addErrorMessage(message);
+    } finally {
+      setRequestPending(false);
+    }
+  };
 
   return (
     <Access access={['project:write']} project={project}>
diff --git a/static/app/views/settings/projectSeer/autofixRepositories.tsx b/static/app/views/settings/projectSeer/autofixRepositories.tsx
index 13598f786ad67a..fa578571cc4340 100644
--- a/static/app/views/settings/projectSeer/autofixRepositories.tsx
+++ b/static/app/views/settings/projectSeer/autofixRepositories.tsx
@@ -177,32 +177,26 @@ export function AutofixRepositories({project}: ProjectSeerProps) {
     [updatePreferences]
   );
 
-  const removeRepository = useCallback(
-    (repoId: string) => {
-      setSelectedRepoIds(prevSelectedIds => {
-        const newIds = prevSelectedIds.filter(id => id !== repoId);
-        updatePreferences(newIds);
-        return newIds;
-      });
-    },
-    [updatePreferences]
-  );
-
-  const updateRepoSettings = useCallback(
-    (repoId: string, settings: RepoSettings) => {
-      setRepoSettings(prev => {
-        const newSettings = {
-          ...prev,
-          [repoId]: settings,
-        };
+  const removeRepository = (repoId: string) => {
+    setSelectedRepoIds(prevSelectedIds => {
+      const newIds = prevSelectedIds.filter(id => id !== repoId);
+      updatePreferences(newIds);
+      return newIds;
+    });
+  };
+
+  const updateRepoSettings = (repoId: string, settings: RepoSettings) => {
+    setRepoSettings(prev => {
+      const newSettings = {
+        ...prev,
+        [repoId]: settings,
+      };
 
-        updatePreferences(undefined, newSettings);
+      updatePreferences(undefined, newSettings);
 
-        return newSettings;
-      });
-    },
-    [updatePreferences]
-  );
+      return newSettings;
+    });
+  };
 
   const {unselectedRepositories, filteredSelectedRepositories} = useMemo(() => {
     if (!repositories || repositories.length === 0) {
@@ -231,7 +225,7 @@ export function AutofixRepositories({project}: ProjectSeerProps) {
 
   const isRepoLimitReached = selectedRepoIds.length >= MAX_REPOS_LIMIT;
 
-  const openAddRepoModal = useCallback(() => {
+  const openAddRepoModal = () => {
     openModal(deps => (
       <AddAutofixRepoModal
         {...deps}
@@ -239,7 +233,7 @@ export function AutofixRepositories({project}: ProjectSeerProps) {
         onSave={handleSaveModalSelections}
       />
     ));
-  }, [selectedRepoIds, handleSaveModalSelections]);
+  };
 
   return (
     <Panel>
diff --git a/static/app/views/settings/seer/overview/codeReviewOverviewSection.tsx b/static/app/views/settings/seer/overview/codeReviewOverviewSection.tsx
index bb218427bf5def..c55513ea86d40e 100644
--- a/static/app/views/settings/seer/overview/codeReviewOverviewSection.tsx
+++ b/static/app/views/settings/seer/overview/codeReviewOverviewSection.tsx
@@ -1,4 +1,3 @@
-import {useCallback} from 'react';
 import {mutationOptions} from '@tanstack/react-query';
 import uniqBy from 'lodash/uniqBy';
 import {z} from 'zod';
@@ -20,8 +19,7 @@ import {t, tct, tn} from 'sentry/locale';
 import {DEFAULT_CODE_REVIEW_TRIGGERS} from 'sentry/types/integrations';
 import type {Organization} from 'sentry/types/organization';
 import {useFetchAllPages} from 'sentry/utils/api/apiFetch';
-import {useInfiniteQuery, useQueryClient} from 'sentry/utils/queryClient';
-import {fetchMutation} from 'sentry/utils/queryClient';
+import {fetchMutation, useInfiniteQuery, useQueryClient} from 'sentry/utils/queryClient';
 import {useOrganization} from 'sentry/utils/useOrganization';
 
 export function useCodeReviewOverviewSection() {
@@ -103,71 +101,65 @@ export function CodeReviewOverviewSection({
     },
   });
 
-  const handleToggleCodeReview = useCallback(
-    (enabledCodeReview: boolean) => {
-      const repositoryIds = (
-        enabledCodeReview
-          ? seerRepos.filter(repo => !repo.settings?.enabledCodeReview)
-          : reposWithCodeReview
-      ).map(repo => repo.id);
-      mutateRepositorySettings(
-        {enabledCodeReview, repositoryIds},
-        {
-          onError: (_, variables) => {
-            addErrorMessage(
-              tn(
-                'Failed to update code review for %s repository',
-                'Failed to update code review for %s repositories',
-                variables.repositoryIds.length
-              )
-            );
-          },
-          onSuccess: (_, variables) => {
-            addSuccessMessage(
-              tn(
-                'Code review updated for %s repository',
-                'Code review updated for %s repositories',
-                variables.repositoryIds.length
-              )
-            );
-          },
-        }
-      );
-    },
-    [mutateRepositorySettings, reposWithCodeReview, seerRepos]
-  );
+  const handleToggleCodeReview = (enabledCodeReview: boolean) => {
+    const repositoryIds = (
+      enabledCodeReview
+        ? seerRepos.filter(repo => !repo.settings?.enabledCodeReview)
+        : reposWithCodeReview
+    ).map(repo => repo.id);
+    mutateRepositorySettings(
+      {enabledCodeReview, repositoryIds},
+      {
+        onError: (_, variables) => {
+          addErrorMessage(
+            tn(
+              'Failed to update code review for %s repository',
+              'Failed to update code review for %s repositories',
+              variables.repositoryIds.length
+            )
+          );
+        },
+        onSuccess: (_, variables) => {
+          addSuccessMessage(
+            tn(
+              'Code review updated for %s repository',
+              'Code review updated for %s repositories',
+              variables.repositoryIds.length
+            )
+          );
+        },
+      }
+    );
+  };
 
-  const handleChangeTriggers = useCallback(
-    (newTriggers: string[]) => {
-      mutateRepositorySettings(
-        {
-          codeReviewTriggers: newTriggers,
-          repositoryIds: seerRepos.map(repo => repo.id),
+  const handleChangeTriggers = (newTriggers: string[]) => {
+    mutateRepositorySettings(
+      {
+        codeReviewTriggers: newTriggers,
+        repositoryIds: seerRepos.map(repo => repo.id),
+      },
+      {
+        onError: (_, variables) => {
+          addErrorMessage(
+            tn(
+              'Failed to update triggers for %s repository',
+              'Failed to update triggers for %s repositories',
+              variables.repositoryIds.length
+            )
+          );
         },
-        {
-          onError: (_, variables) => {
-            addErrorMessage(
-              tn(
-                'Failed to update triggers for %s repository',
-                'Failed to update triggers for %s repositories',
-                variables.repositoryIds.length
-              )
-            );
-          },
-          onSuccess: (_, variables) => {
-            addSuccessMessage(
-              tn(
-                'Triggers updated for %s repository',
-                'Triggers updated for %s repositories',
-                variables.repositoryIds.length
-              )
-            );
-          },
-        }
-      );
-    },
-    [mutateRepositorySettings, seerRepos]
-  );
+        onSuccess: (_, variables) => {
+          addSuccessMessage(
+            tn(
+              'Triggers updated for %s repository',
+              'Triggers updated for %s repositories',
+              variables.repositoryIds.length
+            )
+          );
+        },
+      }
+    );
+  };
 
   return (
     <FieldGroup
diff --git a/static/app/views/setupWizard/wizardProjectSelection.tsx b/static/app/views/setupWizard/wizardProjectSelection.tsx
index 11506350cdd173..7132e0049e408d 100644
--- a/static/app/views/setupWizard/wizardProjectSelection.tsx
+++ b/static/app/views/setupWizard/wizardProjectSelection.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback, useEffect, useMemo, useState} from 'react';
+import {Fragment, useEffect, useMemo, useState} from 'react';
 import styled from '@emotion/styled';
 import {PlatformIcon} from 'platformicons';
 
@@ -221,57 +221,44 @@ export function WizardProjectSelection({
 
   const isFormValid = selectedOrg && isProjectSelected;
 
-  const handleSubmit = useCallback(
-    async (event: React.FormEvent) => {
-      event.preventDefault();
-      if (!isFormValid || !selectedOrg || !selectedProjectId) {
-        return;
-      }
-
-      let projectId = selectedProjectId;
-      try {
-        if (isCreateProjectSelected) {
-          const project = await createProjectMutation.mutateAsync({
-            organization: selectedOrg,
-            team: newProjectTeam,
-            name: newProjectName,
-            platform: newProjectPlatform || platformParam || 'other',
-          });
-
-          projectId = project.id;
-        }
-      } catch {
-        addErrorMessage('Failed to create project! Please try again');
-        return;
-      }
+  const handleSubmit = async (event: React.FormEvent) => {
+    event.preventDefault();
+    if (!isFormValid || !selectedOrg || !selectedProjectId) {
+      return;
+    }
 
-      try {
-        await updateWizardCacheMutation.mutateAsync({
-          organizationId: selectedOrg.id,
-          projectId,
+    let projectId = selectedProjectId;
+    try {
+      if (isCreateProjectSelected) {
+        const project = await createProjectMutation.mutateAsync({
+          organization: selectedOrg,
+          team: newProjectTeam,
+          name: newProjectName,
+          platform: newProjectPlatform || platformParam || 'other',
         });
-      } catch (e) {
-        const errorMessage = errorIsHasNoDsnError(e)
-          ? t(
-              'The selected project has no active DSN. Please add an active DSN to the project.'
-            )
-          : t('Something went wrong! Please try again.');
-
-        addErrorMessage(errorMessage);
+
+        projectId = project.id;
       }
-    },
-    [
-      isFormValid,
-      selectedOrg,
-      selectedProjectId,
-      isCreateProjectSelected,
-      createProjectMutation,
-      newProjectTeam,
-      newProjectName,
-      newProjectPlatform,
-      updateWizardCacheMutation,
-    ]
-  );
+    } catch {
+      addErrorMessage('Failed to create project! Please try again');
+      return;
+    }
+
+    try {
+      await updateWizardCacheMutation.mutateAsync({
+        organizationId: selectedOrg.id,
+        projectId,
+      });
+    } catch (e) {
+      const errorMessage = errorIsHasNoDsnError(e)
+        ? t(
+            'The selected project has no active DSN. Please add an active DSN to the project.'
+          )
+        : t('Something went wrong! Please try again.');
+
+      addErrorMessage(errorMessage);
+    }
+  };
 
   if (isSuccess) {
     return <WaitingForWizardToConnect hash={hash} organizations={organizations} />;
diff --git a/static/gsAdmin/views/broadcasts.tsx b/static/gsAdmin/views/broadcasts.tsx
index 5b1fb3dfcdf3dd..6bcee4a37e147a 100644
--- a/static/gsAdmin/views/broadcasts.tsx
+++ b/static/gsAdmin/views/broadcasts.tsx
@@ -1,4 +1,3 @@
-import {useCallback} from 'react';
 import moment from 'moment-timezone';
 
 import {Button} from '@sentry/scraps/button';
@@ -40,11 +39,11 @@ export function Broadcasts() {
   const hasPermission = ConfigStore.get('user').permissions.has('broadcasts.admin');
   const fields = getBroadcastSchema();
 
-  const handleNewBroadcast = useCallback(() => {
+  const handleNewBroadcast = () => {
     openModal(deps => <CreateBroadcastModal {...deps} fields={fields} />, {
       closeEvents: 'escape-key',
     });
-  }, [fields]);
+  };
 
   return (
     <div>
diff --git a/static/gsApp/components/productUnavailableCTA.tsx b/static/gsApp/components/productUnavailableCTA.tsx
index db779552fc36c5..6d875b8b442a0a 100644
--- a/static/gsApp/components/productUnavailableCTA.tsx
+++ b/static/gsApp/components/productUnavailableCTA.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useEffect, useMemo, useState} from 'react';
+import {useEffect, useMemo, useState} from 'react';
 import styled from '@emotion/styled';
 
 import {Alert} from '@sentry/scraps/alert';
@@ -103,7 +103,7 @@ function RequestUpdateAlert({
     );
   }, [analyticsCommonProps]);
 
-  const handleClick = useCallback(async () => {
+  const handleClick = async () => {
     setLoading(true);
 
     trackGetsentryAnalytics(
@@ -127,7 +127,7 @@ function RequestUpdateAlert({
     }
 
     setLoading(false);
-  }, [api, isAncientPlan, organization, analyticsCommonProps]);
+  };
 
   return (
     <AlertWithCustomMargin
@@ -194,7 +194,7 @@ function UpdatePlanAlert({
     );
   }, [analyticsCommonProps]);
 
-  const handleClick = useCallback(() => {
+  const handleClick = () => {
     trackGetsentryAnalytics(
       'product_unavailable_upsell_alert_button.clicked',
       analyticsCommonProps
@@ -205,7 +205,7 @@ function UpdatePlanAlert({
     }
 
     am2UpsellModal.showModal();
-  }, [analyticsCommonProps, canSelfServe, isAncientPlan, am2UpsellModal]);
+  };
 
   return (
     <AlertWithCustomMargin
diff --git a/static/gsApp/components/profiling/profilingUpgradeModal.tsx b/static/gsApp/components/profiling/profilingUpgradeModal.tsx
index 95ecffdc75cc87..e6264f4d6a6ad0 100644
--- a/static/gsApp/components/profiling/profilingUpgradeModal.tsx
+++ b/static/gsApp/components/profiling/profilingUpgradeModal.tsx
@@ -1,5 +1,5 @@
 import type {ComponentProps} from 'react';
-import {useCallback, useEffect} from 'react';
+import {useEffect} from 'react';
 import {css} from '@emotion/react';
 import styled from '@emotion/styled';
 import * as Sentry from '@sentry/react';
@@ -190,7 +190,7 @@ function ActionButtons({
   const api = useApi();
   const {plan, reservations} = useUpgradeNowParams({organization, subscription});
 
-  const onUpdatePlan = useCallback(async () => {
+  const onUpdatePlan = async () => {
     try {
       await api.requestPromise(`/customers/${organization.slug}/subscription/`, {
         method: 'PUT',
@@ -224,9 +224,9 @@ function ActionButtons({
       Sentry.captureException(err);
       redirectToManage(organization);
     }
-  }, [api, organization, subscription, plan, reservations, onComplete, hasPriceChange]);
+  };
 
-  const onClickManageSubscription = useCallback(() => {
+  const onClickManageSubscription = () => {
     trackGetsentryAnalytics('upgrade_now.modal.manage_sub', {
       organization,
       surface: 'profiling',
@@ -235,7 +235,7 @@ function ActionButtons({
       channel: subscription.channel,
       has_billing_scope: organization.access?.includes('org:billing'),
     });
-  }, [organization, subscription]);
+  };
 
   const hasBillingAccess = organization.access?.includes('org:billing');
 
diff --git a/static/gsApp/components/replayOnboardingCTA.tsx b/static/gsApp/components/replayOnboardingCTA.tsx
index 650ad1f353d465..1137f6f0f1d079 100644
--- a/static/gsApp/components/replayOnboardingCTA.tsx
+++ b/static/gsApp/components/replayOnboardingCTA.tsx
@@ -1,5 +1,5 @@
 import type {ReactNode} from 'react';
-import {Fragment, useCallback, useEffect, useState} from 'react';
+import {Fragment, useEffect, useState} from 'react';
 import styled from '@emotion/styled';
 
 import {Button, LinkButton} from '@sentry/scraps/button';
@@ -55,7 +55,7 @@ function ReplayOnboardingCTAUpsell({
     });
   }, [organization, subscription]);
 
-  const onEmailOwner = useCallback(async () => {
+  const onEmailOwner = async () => {
     await sendReplayOnboardRequest({
       orgSlug: organization.slug,
       api,
@@ -73,7 +73,7 @@ function ReplayOnboardingCTAUpsell({
         });
       },
     });
-  }, [api, organization, subscription, dismiss]);
+  };
 
   const [didClickOpenModal, setDidClickOpenModal] = useState<boolean>();
   const previewData = usePreviewData({
@@ -82,9 +82,9 @@ function ReplayOnboardingCTAUpsell({
     enabled: !subscription.canSelfServe || !hasBillingAccess,
   });
 
-  const handleOpenModal = useCallback(() => {
+  const handleOpenModal = () => {
     setDidClickOpenModal(true);
-  }, []);
+  };
 
   // Once we have 1) previewData, and 2) the user clicked the button; then open the modal
   useEffect(() => {
@@ -146,7 +146,7 @@ function ReplayOnboardingCTAUpsell({
     subscription,
   ]);
 
-  const onClickManageSubscription = useCallback(() => {
+  const onClickManageSubscription = () => {
     trackGetsentryAnalytics('replay.list_page.manage_sub', {
       organization,
       surface: 'replay_onboarding_banner',
@@ -155,7 +155,7 @@ function ReplayOnboardingCTAUpsell({
       channel: subscription.channel,
       has_billing_scope: organization.access?.includes('org:billing'),
     });
-  }, [organization, subscription]);
+  };
 
   if (!subscription.canSelfServe) {
     // Two cases:
diff --git a/static/gsApp/components/upgradeNowModal/actionButtons.tsx b/static/gsApp/components/upgradeNowModal/actionButtons.tsx
index 951355c21aef84..279fa09abe1f20 100644
--- a/static/gsApp/components/upgradeNowModal/actionButtons.tsx
+++ b/static/gsApp/components/upgradeNowModal/actionButtons.tsx
@@ -1,4 +1,3 @@
-import {useCallback} from 'react';
 import styled from '@emotion/styled';
 import * as Sentry from '@sentry/react';
 
@@ -47,7 +46,7 @@ export function ActionButtons({
 }: Props) {
   const api = useApi();
 
-  const onUpdatePlan = useCallback(async () => {
+  const onUpdatePlan = async () => {
     try {
       await api.requestPromise(`/customers/${organization.slug}/subscription/`, {
         method: 'PUT',
@@ -82,18 +81,9 @@ export function ActionButtons({
       Sentry.captureException(err);
       redirectToManage(organization);
     }
-  }, [
-    api,
-    onComplete,
-    organization,
-    plan,
-    previewData.billedAmount,
-    reservations,
-    subscription,
-    surface,
-  ]);
-
-  const onEmailOwner = useCallback(async () => {
+  };
+
+  const onEmailOwner = async () => {
     const currentPlanName =
       subscription.planTier === PlanTier.AM2 ? 'am2-non-beta' : 'am1-non-beta';
 
@@ -117,9 +107,9 @@ export function ActionButtons({
         redirectToManage(organization);
       },
     });
-  }, [api, organization, subscription, surface, onComplete]);
+  };
 
-  const onClickManageSubscription = useCallback(() => {
+  const onClickManageSubscription = () => {
     trackGetsentryAnalytics('upgrade_now.modal.manage_sub', {
       organization,
       surface,
@@ -128,7 +118,7 @@ export function ActionButtons({
       channel: subscription.channel,
       has_billing_scope: organization.access?.includes('org:billing'),
     });
-  }, [organization, subscription, surface]);
+  };
 
   const hasBillingAccess = organization.access?.includes('org:billing');
 
diff --git a/static/gsApp/components/upgradeNowModal/modalSamePrice.tsx b/static/gsApp/components/upgradeNowModal/modalSamePrice.tsx
index ae855f7c77cc74..bd86f9b66c0ba7 100644
--- a/static/gsApp/components/upgradeNowModal/modalSamePrice.tsx
+++ b/static/gsApp/components/upgradeNowModal/modalSamePrice.tsx
@@ -1,4 +1,3 @@
-import {useCallback} from 'react';
 import {css} from '@emotion/react';
 import styled from '@emotion/styled';
 import * as Sentry from '@sentry/react';
@@ -44,7 +43,7 @@ function UpgradeNowModal({
 
   const api = useApi();
 
-  const onUpdatePlan = useCallback(async () => {
+  const onUpdatePlan = async () => {
     try {
       await api.requestPromise(`/customers/${organization.slug}/subscription/`, {
         method: 'PUT',
@@ -82,7 +81,7 @@ function UpgradeNowModal({
         )
       );
     }
-  }, [api, organization, subscription, plan, reservations, onComplete, surface]);
+  };
 
   return (
     <UpsellContent>
diff --git a/static/gsApp/views/amCheckout/steps/setSpendLimit.tsx b/static/gsApp/views/amCheckout/steps/setSpendLimit.tsx
index 5da438b53e427a..e8235417608f1d 100644
--- a/static/gsApp/views/amCheckout/steps/setSpendLimit.tsx
+++ b/static/gsApp/views/amCheckout/steps/setSpendLimit.tsx
@@ -1,5 +1,3 @@
-import {useCallback} from 'react';
-
 import {Flex} from '@sentry/scraps/layout';
 
 import {t} from 'sentry/locale';
@@ -25,27 +23,24 @@ export function SetSpendLimit({
   subscription,
   checkoutTier,
 }: StepProps) {
-  const handleBudgetChange = useCallback(
-    ({onDemandBudgets}: {onDemandBudgets: OnDemandBudgets}) => {
-      const totalBudget = getTotalBudget(onDemandBudgets);
-      onUpdate({
-        ...formData,
-        onDemandBudget: onDemandBudgets,
-        onDemandMaxSpend: totalBudget,
-      });
+  const handleBudgetChange = ({onDemandBudgets}: {onDemandBudgets: OnDemandBudgets}) => {
+    const totalBudget = getTotalBudget(onDemandBudgets);
+    onUpdate({
+      ...formData,
+      onDemandBudget: onDemandBudgets,
+      onDemandMaxSpend: totalBudget,
+    });
 
-      if (organization) {
-        trackGetsentryAnalytics('checkout.payg_changed', {
-          organization,
-          subscription,
-          plan: formData.plan,
-          cents: totalBudget || 0,
-          method: 'textbox',
-        });
-      }
-    },
-    [onUpdate, organization, subscription, formData]
-  );
+    if (organization) {
+      trackGetsentryAnalytics('checkout.payg_changed', {
+        organization,
+        subscription,
+        plan: formData.plan,
+        cents: totalBudget || 0,
+        method: 'textbox',
+      });
+    }
+  };
 
   return (
     <Flex direction="column" gap="2xl" id={`step${stepNumber}`}>
diff --git a/static/gsApp/views/seerAutomation/components/projectDetails/autofixRepositoriesItem.tsx b/static/gsApp/views/seerAutomation/components/projectDetails/autofixRepositoriesItem.tsx
index 2a76b6de72a7bb..24d3d724dad4d8 100644
--- a/static/gsApp/views/seerAutomation/components/projectDetails/autofixRepositoriesItem.tsx
+++ b/static/gsApp/views/seerAutomation/components/projectDetails/autofixRepositoriesItem.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback, useState} from 'react';
+import {Fragment, useState} from 'react';
 import styled from '@emotion/styled';
 
 import {Button} from '@sentry/scraps/button';
@@ -60,43 +60,37 @@ export function AutofixRepositoriesItem({
     repository.branch_overrides || []
   );
 
-  const handleUpdateOverride = useCallback(
-    (idx: number, updatedOverride: BranchOverride) => {
-      const newLocalOverrides = localOverrides.toSpliced(idx, 1, updatedOverride);
-      setLocalOverrides(newLocalOverrides);
-
-      // Only sync valid overrides to the server if they changed
-      const branchOverrides = newLocalOverrides.filter(isOverrideValid);
-      if (!areOverridesEqual(branchOverrides, repository.branch_overrides || [])) {
-        onUpdateRepo({
-          ...repository,
-          branch_overrides: branchOverrides,
-        });
-      }
-    },
-    [localOverrides, repository, onUpdateRepo]
-  );
-
-  const handleRemoveOverride = useCallback(
-    (idx: number) => {
-      const newLocalOverrides = localOverrides.toSpliced(idx, 1);
-      setLocalOverrides(newLocalOverrides);
-
-      // Sync valid overrides to the server if they changed
-      const branchOverrides = newLocalOverrides.filter(isOverrideValid);
-      if (!areOverridesEqual(branchOverrides, repository.branch_overrides || [])) {
-        onUpdateRepo({
-          ...repository,
-          branch_overrides: branchOverrides,
-        });
-      }
-    },
-    [localOverrides, repository, onUpdateRepo]
-  );
-
-  const handleAddOverride = useCallback(() => {
+  const handleUpdateOverride = (idx: number, updatedOverride: BranchOverride) => {
+    const newLocalOverrides = localOverrides.toSpliced(idx, 1, updatedOverride);
+    setLocalOverrides(newLocalOverrides);
+
+    // Only sync valid overrides to the server if they changed
+    const branchOverrides = newLocalOverrides.filter(isOverrideValid);
+    if (!areOverridesEqual(branchOverrides, repository.branch_overrides || [])) {
+      onUpdateRepo({
+        ...repository,
+        branch_overrides: branchOverrides,
+      });
+    }
+  };
+
+  const handleRemoveOverride = (idx: number) => {
+    const newLocalOverrides = localOverrides.toSpliced(idx, 1);
+    setLocalOverrides(newLocalOverrides);
+
+    // Sync valid overrides to the server if they changed
+    const branchOverrides = newLocalOverrides.filter(isOverrideValid);
+    if (!areOverridesEqual(branchOverrides, repository.branch_overrides || [])) {
+      onUpdateRepo({
+        ...repository,
+        branch_overrides: branchOverrides,
+      });
+    }
+  };
+
+  const handleAddOverride = () => {
     setLocalOverrides([...localOverrides, {...DEFAULT_OVERRIDE}]);
-  }, [localOverrides]);
+  };
 
   return (
     <Fragment>
diff --git a/static/gsApp/views/seerAutomation/components/projectDetails/autofixRepositoriesList.tsx b/static/gsApp/views/seerAutomation/components/projectDetails/autofixRepositoriesList.tsx
index 213f8b381131a4..6fa554ffe3b775 100644
--- a/static/gsApp/views/seerAutomation/components/projectDetails/autofixRepositoriesList.tsx
+++ b/static/gsApp/views/seerAutomation/components/projectDetails/autofixRepositoriesList.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useMemo} from 'react';
+import {useMemo} from 'react';
 import styled from '@emotion/styled';
 import seerConfigBug1 from 'getsentry-images/spot/seer-config-bug-1.svg';
 
@@ -70,27 +70,24 @@ export function AutofixRepositories({canWrite, preference, project}: Props) {
     [preference]
   );
 
-  const handleSaveRepoList = useCallback(
-    (updatedRepositories: SeerRepoDefinition[]) => {
-      updateProjectSeerPreferences(
-        {
-          repositories: updatedRepositories,
-          automated_run_stopping_point: preference?.automated_run_stopping_point,
-          automation_handoff: preference?.automation_handoff,
-        },
-        {
-          onError: () => addErrorMessage(t('Failed to connect repositories')),
-          onSuccess: () =>
-            addSuccessMessage(
-              t('%s repo(s) connected to %s', updatedRepositories.length, project.slug)
-            ),
-        }
-      );
-    },
-    [updateProjectSeerPreferences, preference, project.slug]
-  );
+  const handleSaveRepoList = (updatedRepositories: SeerRepoDefinition[]) => {
+    updateProjectSeerPreferences(
+      {
+        repositories: updatedRepositories,
+        automated_run_stopping_point: preference?.automated_run_stopping_point,
+        automation_handoff: preference?.automation_handoff,
+      },
+      {
+        onError: () => addErrorMessage(t('Failed to connect repositories')),
+        onSuccess: () =>
+          addSuccessMessage(
+            t('%s repo(s) connected to %s', updatedRepositories.length, project.slug)
+          ),
+      }
+    );
+  };
 
-  const handleAddRepoClick = useCallback(() => {
+  const handleAddRepoClick = () => {
     openModal(deps => (
       <AddAutofixRepoModal
         {...deps}
@@ -123,7 +120,7 @@ export function AutofixRepositories({canWrite, preference, project}: Props) {
         }}
       />
     ));
-  }, [repoMap, handleSaveRepoList, repositories, organization.id]);
+  };
 
   if (isFetchingRepositories) {
     return <LoadingIndicator />;
diff --git a/static/gsApp/views/seerAutomation/onboarding/configureCodeReviewStep.tsx b/static/gsApp/views/seerAutomation/onboarding/configureCodeReviewStep.tsx
index b4151e769be8f0..4dbe489d6eab4f 100644
--- a/static/gsApp/views/seerAutomation/onboarding/configureCodeReviewStep.tsx
+++ b/static/gsApp/views/seerAutomation/onboarding/configureCodeReviewStep.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback} from 'react';
+import {Fragment} from 'react';
 import styled from '@emotion/styled';
 import * as Sentry from '@sentry/react';
 
@@ -42,7 +42,7 @@ export function ConfigureCodeReviewStep() {
   const {mutate: updateRepositorySettings, isPending: isUpdateRepositorySettingsPending} =
     useBulkUpdateRepositorySettings();
 
-  const handleNextStep = useCallback(() => {
+  const handleNextStep = () => {
     const existingRepostoriesToRemove = unselectedCodeReviewRepositories
       .filter(repo => repo.settings?.enabledCodeReview)
       .map(repo => repo.id);
@@ -134,15 +134,7 @@ export function ConfigureCodeReviewStep() {
           t('Failed to update AI Code Review settings, reload and try again')
         );
       });
-  }, [
-    clearRootCauseAnalysisRepositories,
-    selectedCodeReviewRepositories,
-    unselectedCodeReviewRepositories,
-    currentStep,
-    setCurrentStep,
-    updateRepositorySettings,
-    organization,
-  ]);
+  };
 
   return (
     <Fragment>
diff --git a/static/gsApp/views/seerAutomation/onboarding/configureDefaultsStep.tsx b/static/gsApp/views/seerAutomation/onboarding/configureDefaultsStep.tsx
index d3057546eee824..b3eb9ad600cad7 100644
--- a/static/gsApp/views/seerAutomation/onboarding/configureDefaultsStep.tsx
+++ b/static/gsApp/views/seerAutomation/onboarding/configureDefaultsStep.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback, useState} from 'react';
+import {Fragment, useState} from 'react';
 import styled from '@emotion/styled';
 import * as Sentry from '@sentry/react';
 
@@ -49,11 +49,11 @@ export function ConfigureDefaultsStep() {
   const {mutate: updateOrganization, isPending: isUpdateOrganizationPending} =
     useUpdateOrganization(organization);
 
-  const handlePreviousStep = useCallback(() => {
+  const handlePreviousStep = () => {
     setCurrentStep(currentStep - 1);
-  }, [setCurrentStep, currentStep]);
+  };
 
-  const handleNextStep = useCallback(() => {
+  const handleNextStep = () => {
     updateOrganization(
       {
         defaultAutofixAutomationTuning: proposeFixesEnabled ? 'medium' : 'off',
@@ -82,15 +82,7 @@ export function ConfigureDefaultsStep() {
         },
       }
     );
-  }, [
-    autoCreatePREnabled,
-    enableCodeReview,
-    proposeFixesEnabled,
-    updateOrganization,
-    currentStep,
-    setCurrentStep,
-    organization,
-  ]);
+  };
 
   return (
     <Fragment>
diff --git a/static/gsApp/views/seerAutomation/onboarding/configureRootCauseAnalysisStep.tsx b/static/gsApp/views/seerAutomation/onboarding/configureRootCauseAnalysisStep.tsx
index 6c95324d778aa3..7b406ecde1b33d 100644
--- a/static/gsApp/views/seerAutomation/onboarding/configureRootCauseAnalysisStep.tsx
+++ b/static/gsApp/views/seerAutomation/onboarding/configureRootCauseAnalysisStep.tsx
@@ -88,11 +88,11 @@ export function ConfigureRootCauseAnalysisStep() {
     addRepositoryProjectMappings,
   ]);
 
-  const handlePreviousStep = useCallback(() => {
+  const handlePreviousStep = () => {
     setCurrentStep(currentStep - 1);
-  }, [setCurrentStep, currentStep]);
+  };
 
-  const handleNextStep = useCallback(() => {
+  const handleNextStep = () => {
     // Build a map from repo ID to full repo object
     const repoMap = new Map(
       selectedRootCauseAnalysisRepositories.map(repo => [repo.id, repo])
@@ -162,16 +162,7 @@ export function ConfigureRootCauseAnalysisStep() {
         },
       }
     );
-  }, [
-    setCurrentStep,
-    currentStep,
-    updateAutofix,
-    repositoryProjectMapping,
-    selectedRootCauseAnalysisRepositories,
-    autoCreatePREnabled,
-    organization,
-    setAutoCreatePR,
-  ]);
+  };
 
   const handleRepositoryProjectMappingsChange = useCallback(
     (repoId: string, index: number, newValue: string | undefined) => {
@@ -190,12 +181,9 @@ export function ConfigureRootCauseAnalysisStep() {
     [changeRepositoryProjectMapping, repositoryProjectMapping]
   );
 
-  const handleAutoCreatePRChange = useCallback(
-    (e: React.ChangeEvent<HTMLInputElement>) => {
-      setAutoCreatePREnabled(e.target.checked);
-    },
-    [setAutoCreatePREnabled]
-  );
+  const handleAutoCreatePRChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    setAutoCreatePREnabled(e.target.checked);
+  };
 
   const availableRepositories = useMemo(() => {
     return (
diff --git a/static/gsApp/views/seerAutomation/onboarding/onboardingLegacy.tsx b/static/gsApp/views/seerAutomation/onboarding/onboardingLegacy.tsx
index 2e528aa18bf0af..dd6c756fa02341 100644
--- a/static/gsApp/views/seerAutomation/onboarding/onboardingLegacy.tsx
+++ b/static/gsApp/views/seerAutomation/onboarding/onboardingLegacy.tsx
@@ -438,7 +438,7 @@ function AutoTriggerFixesButton({
   const {setCurrentStep, getStepNumber} = useGuidedStepsContext();
   const [isLoading, setIsLoading] = useState(false);
 
-  const handleEnableAutoTriggerFixes = useCallback(async () => {
+  const handleEnableAutoTriggerFixes = async () => {
     if (projectsWithRepos.length === 0) {
       addErrorMessage(t('No projects with repositories found to update'));
       return;
@@ -491,15 +491,7 @@ function AutoTriggerFixesButton({
     } finally {
       setIsLoading(false);
     }
-  }, [
-    api,
-    organization.slug,
-    projectsWithRepos,
-    selectedThreshold,
-    queryClient,
-    getStepNumber,
-    setCurrentStep,
-  ]);
+  };
 
   return (
     <Button
@@ -526,7 +518,7 @@ function EnableIssueScansButton({
   const {setCurrentStep, getStepNumber} = useGuidedStepsContext();
   const [isLoading, setIsLoading] = useState(false);
 
-  const handleEnableIssueScans = useCallback(async () => {
+  const handleEnableIssueScans = async () => {
     if (projectsWithoutRepos.length === 0) {
       addErrorMessage(t('No remaining projects found to update'));
       return;
@@ -573,14 +565,7 @@ function EnableIssueScansButton({
     } finally {
       setIsLoading(false);
     }
-  }, [
-    api,
-    organization.slug,
-    projectsWithoutRepos,
-    queryClient,
-    getStepNumber,
-    setCurrentStep,
-  ]);
+  };
 
   return (
     <Button
diff --git a/static/gsApp/views/seerAutomation/onboarding/repositorySelector.tsx b/static/gsApp/views/seerAutomation/onboarding/repositorySelector.tsx
index bbdf97025fa656..18719fa35e83c9 100644
--- a/static/gsApp/views/seerAutomation/onboarding/repositorySelector.tsx
+++ b/static/gsApp/views/seerAutomation/onboarding/repositorySelector.tsx
@@ -62,7 +62,7 @@ export function RepositorySelector() {
   const allUnselected = selected.length === 0;
 
   // This is gonna lag if we have a lot of repositories, as we need to re-render all rows
-  const handleToggleAll = useCallback(() => {
+  const handleToggleAll = () => {
     if (allSelected) {
       setCodeReviewRepositories(
         Object.fromEntries(filteredRepositories.map(repo => [repo.id, false]))
@@ -73,7 +73,7 @@ export function RepositorySelector() {
     setCodeReviewRepositories(
       Object.fromEntries(filteredRepositories.map(repo => [repo.id, true]))
     );
-  }, [allSelected, filteredRepositories, setCodeReviewRepositories]);
+  };
 
   const handleToggleRepository = useCallback(
     (repositoryId: string, newValue: boolean) => {
diff --git a/static/gsApp/views/seerAutomation/onboarding/repositoryToProjectConfiguration.tsx b/static/gsApp/views/seerAutomation/onboarding/repositoryToProjectConfiguration.tsx
index ed497aa1e9300e..846c3d63accb75 100644
--- a/static/gsApp/views/seerAutomation/onboarding/repositoryToProjectConfiguration.tsx
+++ b/static/gsApp/views/seerAutomation/onboarding/repositoryToProjectConfiguration.tsx
@@ -1,4 +1,4 @@
-import {Fragment, memo, useCallback, useMemo} from 'react';
+import {Fragment, memo, useMemo} from 'react';
 import styled from '@emotion/styled';
 import partition from 'lodash/partition';
 
@@ -134,19 +134,16 @@ const RepositoryRow = memo(function RepositoryRow({
       : memberProjects.map(getProjectItem);
   }, [memberProjects, nonMemberProjects]);
 
-  const handleRepositoryChange = useCallback(
-    (option: SelectValue<string> | null) => {
-      if (option === null) {
-        onRemoveRepository?.(repository.id);
-        return;
-      }
-
-      if (option?.value && option.value !== repository.id) {
-        onChangeRepository(repository.id, option.value);
-      }
-    },
-    [repository.id, onChangeRepository, onRemoveRepository]
-  );
+  const handleRepositoryChange = (option: SelectValue<string> | null) => {
+    if (option === null) {
+      onRemoveRepository?.(repository.id);
+      return;
+    }
+
+    if (option?.value && option.value !== repository.id) {
+      onChangeRepository(repository.id, option.value);
+    }
+  };
 
   return (
     <MappingItem key={repository.id}>
diff --git a/static/gsApp/views/seerAutomation/onboarding/wrapUpStep.tsx b/static/gsApp/views/seerAutomation/onboarding/wrapUpStep.tsx
index f63b6a25ae36c1..6ddea2f0e26faa 100644
--- a/static/gsApp/views/seerAutomation/onboarding/wrapUpStep.tsx
+++ b/static/gsApp/views/seerAutomation/onboarding/wrapUpStep.tsx
@@ -1,4 +1,4 @@
-import {Fragment, useCallback, useMemo} from 'react';
+import {Fragment, useMemo} from 'react';
 import styled from '@emotion/styled';
 
 import nextStepsImg from 'sentry-images/spot/seer-config-bug-2.svg';
@@ -21,9 +21,9 @@ export function WrapUpStep() {
     useSeerOnboardingContext();
   const {currentStep, setCurrentStep} = useGuidedStepsContext();
 
-  const handlePreviousStep = useCallback(() => {
+  const handlePreviousStep = () => {
     setCurrentStep(currentStep - 1);
-  }, [setCurrentStep, currentStep]);
+  };
 
   const hasCodeReview = useMemo(
     () => selectedCodeReviewRepositories.length > 0,
diff --git a/static/gsApp/views/spikeProtection/spikeProtectionProjects.tsx b/static/gsApp/views/spikeProtection/spikeProtectionProjects.tsx
index 0de9ed330883de..165ff7dc9ff6d4 100644
--- a/static/gsApp/views/spikeProtection/spikeProtectionProjects.tsx
+++ b/static/gsApp/views/spikeProtection/spikeProtectionProjects.tsx
@@ -121,55 +121,49 @@ function SpikeProtectionProjects({subscription}: Props) {
     setIsLoading(false);
   }, [fetchAvailableNotificationActions]);
 
-  const fetchProjectNotificationActions = useCallback(
-    async (
-      project: Project,
-      projectNotificationActions: Record<string, NotificationAction[]>
-    ) => {
-      const projectId = project.id;
-      const data = await api.requestPromise(
-        `/organizations/${organization.slug}/notifications/actions/`,
-        {query: {triggerType, project: projectId}}
-      );
-
-      const notifActionsById = {...projectNotificationActions};
-      data.forEach((action: NotificationAction) => {
-        if (notifActionsById[projectId]) {
-          notifActionsById[projectId].push(action);
-        } else {
-          notifActionsById[projectId] = [action];
-        }
-      });
-      setNotificationActionsById(notifActionsById);
-    },
-    [api, organization]
-  );
+  const fetchProjectNotificationActions = async (
+    project: Project,
+    projectNotificationActions: Record<string, NotificationAction[]>
+  ) => {
+    const projectId = project.id;
+    const data = await api.requestPromise(
+      `/organizations/${organization.slug}/notifications/actions/`,
+      {query: {triggerType, project: projectId}}
+    );
 
-  const updateAllProjects = useCallback(
-    async (isEnabling: boolean) => {
-      try {
-        await api.requestPromise(
-          `/organizations/${organization.slug}/spike-protections/?projectSlug=$all`,
-          {method: isEnabling ? 'POST' : 'DELETE', data: {projects: []}}
-        );
-        const newProjects = projects.map(p => ({
-          ...p,
-          options: {...p.options, [SPIKE_PROTECTION_OPTION_DISABLED]: !isEnabling},
-        }));
-        setProjects(newProjects);
-        await fetchData();
-        addSuccessMessage(
-          tct('[action] spike protection for all projects', {
-            action: isEnabling ? t('Enabled') : t('Disabled'),
-          })
-        );
-      } catch (err) {
-        Sentry.captureException(err);
-        addErrorMessage(SPIKE_PROTECTION_ERROR_MESSAGE);
+    const notifActionsById = {...projectNotificationActions};
+    data.forEach((action: NotificationAction) => {
+      if (notifActionsById[projectId]) {
+        notifActionsById[projectId].push(action);
+      } else {
+        notifActionsById[projectId] = [action];
       }
-    },
-    [api, organization, projects, fetchData]
-  );
+    });
+    setNotificationActionsById(notifActionsById);
+  };
+
+  const updateAllProjects = async (isEnabling: boolean) => {
+    try {
+      await api.requestPromise(
+        `/organizations/${organization.slug}/spike-protections/?projectSlug=$all`,
+        {method: isEnabling ? 'POST' : 'DELETE', data: {projects: []}}
+      );
+      const newProjects = projects.map(p => ({
+        ...p,
+        options: {...p.options, [SPIKE_PROTECTION_OPTION_DISABLED]: !isEnabling},
+      }));
+      setProjects(newProjects);
+      await fetchData();
+      addSuccessMessage(
+        tct('[action] spike protection for all projects', {
+          action: isEnabling ? t('Enabled') : t('Disabled'),
+        })
+      );
+    } catch (err) {
+      Sentry.captureException(err);
+      addErrorMessage(SPIKE_PROTECTION_ERROR_MESSAGE);
+    }
+  };
 
   useEffect(() => {
     fetchProjects();

From 61e851be3bd2461d655f9fdcf24eb1bf8d5baafa Mon Sep 17 00:00:00 2001
From: TkDodo <office@dorfmeister.cc>
Date: Tue, 14 Apr 2026 10:23:03 +0200
Subject: [PATCH 10/14] ref: remove unnecessary useCallback

---
 .../components/pipeline/pipelineIntegrationAwsLambda.tsx    | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/static/app/components/pipeline/pipelineIntegrationAwsLambda.tsx b/static/app/components/pipeline/pipelineIntegrationAwsLambda.tsx
index a14f1e53e5a070..07ca1e28cc1dca 100644
--- a/static/app/components/pipeline/pipelineIntegrationAwsLambda.tsx
+++ b/static/app/components/pipeline/pipelineIntegrationAwsLambda.tsx
@@ -1,4 +1,4 @@
-import {useCallback, useEffect, useMemo, useState} from 'react';
+import {useEffect, useMemo, useState} from 'react';
 import styled from '@emotion/styled';
 import debounce from 'lodash/debounce';
 import {z} from 'zod';
@@ -164,13 +164,13 @@ function CloudFormationStep({
 
   const regionOptions = stepData.regionList.map(r => ({value: r, label: r}));
 
-  const trackCloudFormationClick = useCallback(() => {
+  const trackCloudFormationClick = () => {
     trackIntegrationAnalytics('integrations.cloudformation_link_clicked', {
       integration: 'aws_lambda',
       integration_type: 'first_party',
       organization,
     });
-  }, [organization]);
+  };
 
   const form = useScrapsForm({
     ...defaultFormOptions,

From 8c672509edc9dc88a8f424d7d712843e02f11822 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dominik=20Dorfmeister=20=F0=9F=94=AE?=
 <dominik.dorfmeister@sentry.io>
Date: Tue, 14 Apr 2026 17:25:12 +0200
Subject: [PATCH 11/14] Apply suggestions from code review
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Josh Goldberg ✨ <github@joshuakgoldberg.com>
---
 .../no-unnecessary-use-callback.ts            | 22 +++++--------------
 1 file changed, 6 insertions(+), 16 deletions(-)

diff --git a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
index 48c309420dab52..632527dbe2edab 100644
--- a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
+++ b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
@@ -20,10 +20,7 @@ function formatUsages(usages: UsageInfo[]): string {
     .join(' and ');
 }
 
-export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs<
-  readonly unknown[],
-  'unnecessaryUseCallback' | 'removeUseCallback'
->({
+export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
   meta: {
     type: 'suggestion',
     docs: {
@@ -51,7 +48,7 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs<
     // Local names imported from @sentry/scraps (these components are never memoized)
     const scrapsImports = new Set<string>();
 
-    function addFlaggedUsage(name: string, usage: UsageInfo, refCount: number) {
+    function addFlaggedUsage(name: string, usage: UsageInfo) {
       let usages = flaggedUsages.get(name);
       if (!usages) {
         usages = [];
@@ -100,17 +97,10 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs<
       return null;
     }
 
-    function getJSXElementName(nameNode: TSESTree.JSXTagNameExpression): string | null {
-      if (nameNode.type === AST_NODE_TYPES.JSXIdentifier) {
-        return nameNode.name;
-      }
-      if (
-        nameNode.type === AST_NODE_TYPES.JSXMemberExpression &&
-        nameNode.object.type === AST_NODE_TYPES.JSXIdentifier
-      ) {
-        return nameNode.object.name;
-      }
-      return null;
+    function getJSXElementName(nameNode: TSESTree.JSXTagNameExpression) {
+      return nameNode.type === AST_NODE_TYPES.JSXIdentifier
+        ? nameNode.name
+        : getStaticValue(nameNode)?.value?.toString();
     }
 
     // Scraps components that use memoized callbacks internally

From 9746033f15b7fe4433716eb64106d2af99453afc Mon Sep 17 00:00:00 2001
From: TkDodo <office@dorfmeister.cc>
Date: Tue, 14 Apr 2026 17:26:55 +0200
Subject: [PATCH 12/14] inline function

---
 static/app/components/assistant/guideAnchor.tsx | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/static/app/components/assistant/guideAnchor.tsx b/static/app/components/assistant/guideAnchor.tsx
index 0abd2af11e2980..9c056b1bde5559 100644
--- a/static/app/components/assistant/guideAnchor.tsx
+++ b/static/app/components/assistant/guideAnchor.tsx
@@ -105,13 +105,6 @@ function BaseGuideAnchor({
     [onStepComplete]
   );
 
-  const handleDismiss = (e: React.MouseEvent) => {
-    e.stopPropagation();
-    if (currentGuide) {
-      dismissGuide(currentGuide.guide, step, orgId);
-    }
-  };
-
   if (!active) {
     return children ? children : null;
   }
@@ -130,7 +123,10 @@ function BaseGuideAnchor({
       stepCount={currentStepCount}
       stepTotal={totalStepCount}
       handleDismiss={e => {
-        handleDismiss(e);
+        e.stopPropagation();
+        if (currentGuide) {
+          dismissGuide(currentGuide.guide, step, orgId);
+        }
         window.location.hash = '';
       }}
       actions={

From 5f1c627ccff79c8a2e29415a5e7d6dd4385b9df8 Mon Sep 17 00:00:00 2001
From: TkDodo <office@dorfmeister.cc>
Date: Tue, 14 Apr 2026 18:03:41 +0200
Subject: [PATCH 13/14] fix: compile errors

---
 .../no-unnecessary-use-callback.ts            | 44 +++++++++----------
 1 file changed, 20 insertions(+), 24 deletions(-)

diff --git a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
index 632527dbe2edab..27ed57283366ec 100644
--- a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
+++ b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
@@ -1,4 +1,5 @@
 import {AST_NODE_TYPES, ESLintUtils, type TSESTree} from '@typescript-eslint/utils';
+import {getStaticValue} from '@typescript-eslint/utils/ast-utils';
 
 interface UsageInfo {
   line: number;
@@ -55,7 +56,11 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
         flaggedUsages.set(name, usages);
       }
       usages.push(usage);
-      flaggedRefCount.set(name, (flaggedRefCount.get(name) ?? 0) + refCount);
+      flaggedRefCount.set(
+        name,
+        (flaggedRefCount.get(name) ?? 0) +
+          1 /* each usage accounts for one reference to the binding */
+      );
     }
 
     /**
@@ -147,11 +152,10 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
         if (expr.type === AST_NODE_TYPES.ArrowFunctionExpression) {
           const calledBinding = findCallToBinding(expr.body);
           if (calledBinding) {
-            addFlaggedUsage(
-              calledBinding,
-              {reason: 'directlyInvoked', line: node.value.loc.start.line},
-              1
-            );
+            addFlaggedUsage(calledBinding, {
+              reason: 'directlyInvoked',
+              line: node.value.loc.start.line,
+            });
             return;
           }
         }
@@ -180,25 +184,17 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
             tagName.type === AST_NODE_TYPES.JSXIdentifier &&
             tagName.name[0] === tagName.name[0]?.toLowerCase()
           ) {
-            addFlaggedUsage(
-              expr.name,
-              {
-                reason: 'intrinsicElement',
-                element: tagName.name,
-                line: node.value.loc.start.line,
-              },
-              1
-            );
+            addFlaggedUsage(expr.name, {
+              reason: 'intrinsicElement',
+              element: tagName.name,
+              line: node.value.loc.start.line,
+            });
           } else if (elementName && scrapsImports.has(elementName)) {
-            addFlaggedUsage(
-              expr.name,
-              {
-                reason: 'unmemoizedComponent',
-                element: elementName,
-                line: node.value.loc.start.line,
-              },
-              1
-            );
+            addFlaggedUsage(expr.name, {
+              reason: 'unmemoizedComponent',
+              element: elementName,
+              line: node.value.loc.start.line,
+            });
           }
         }
       },

From 1b7f935e2ee84ea43d1ea222a449d76885b0c168 Mon Sep 17 00:00:00 2001
From: TkDodo <office@dorfmeister.cc>
Date: Wed, 15 Apr 2026 09:47:23 +0200
Subject: [PATCH 14/14] ref: enhance handling of shadowed identifiers in
 useCallback

---
 .../no-unnecessary-use-callback.spec.ts       |  84 +++++++++++++
 .../no-unnecessary-use-callback.ts            | 115 ++++++++++++------
 2 files changed, 161 insertions(+), 38 deletions(-)

diff --git a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
index ee0c3f3087ee4b..ea9a3edf2a2472 100644
--- a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
+++ b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.spec.ts
@@ -140,6 +140,26 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
         <CodeBlock onCopy={fn} />
       `,
     },
+    {
+      name: 'bug: shadowed callee inside arrow',
+      code: `
+        const fn = useCallback(() => {}, []);
+        (() => {
+          const fn = () => {};
+          return <button onClick={() => fn()} />;
+        })();
+      `,
+    },
+    {
+      name: 'bug: shadowed identifier on direct prop',
+      code: `
+        const fn = useCallback(() => {}, []);
+        (() => {
+          const fn = () => {};
+          return <button onClick={fn} />;
+        })();
+      `,
+    },
   ],
 
   invalid: [
@@ -433,5 +453,69 @@ ruleTester.run('no-unnecessary-use-callback', noUnnecessaryUseCallback, {
         },
       ],
     },
+    {
+      name: 'bug: aliased useCallback import should still be tracked',
+      code: `
+        import {useCallback as uc} from 'react';
+        const fn = uc(() => {}, []);
+        <button onClick={fn} />
+      `,
+      errors: [
+        {
+          messageId: 'unnecessaryUseCallback',
+          data: {
+            name: 'fn',
+            usages: 'passed to intrinsic element <button> in line 4',
+          },
+          suggestions: [
+            {
+              messageId: 'removeUseCallback',
+              output: `
+        import {useCallback as uc} from 'react';
+        const fn = () => {};
+        <button onClick={fn} />
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      name: 'bug: same binding name in sibling functions only flags the intrinsic one',
+      code: `
+        function B() {
+          const fn = useCallback(() => {}, []);
+          return <button onClick={fn} />;
+        }
+        function A() {
+          const fn = useCallback(() => {}, []);
+          return <Memo onClick={fn} />;
+        }
+      `,
+      errors: [
+        {
+          messageId: 'unnecessaryUseCallback',
+          data: {
+            name: 'fn',
+            usages: 'passed to intrinsic element <button> in line 4',
+          },
+          suggestions: [
+            {
+              messageId: 'removeUseCallback',
+              output: `
+        function B() {
+          const fn = () => {};
+          return <button onClick={fn} />;
+        }
+        function A() {
+          const fn = useCallback(() => {}, []);
+          return <Memo onClick={fn} />;
+        }
+      `,
+            },
+          ],
+        },
+      ],
+    },
   ],
 });
diff --git a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
index 27ed57283366ec..0a9d35a6cf224d 100644
--- a/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
+++ b/static/eslint/eslintPluginSentry/no-unnecessary-use-callback.ts
@@ -1,5 +1,6 @@
 import {AST_NODE_TYPES, ESLintUtils, type TSESTree} from '@typescript-eslint/utils';
 import {getStaticValue} from '@typescript-eslint/utils/ast-utils';
+import type {Scope} from '@typescript-eslint/utils/ts-eslint';
 
 interface UsageInfo {
   line: number;
@@ -37,44 +38,64 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
     },
   },
   create(context) {
-    // Maps binding name to the useCallback() CallExpression node and its declaring scope
+    // Maps scope Variable to the useCallback() CallExpression node and its declaring scope
     const useCallbackBindings = new Map<
-      string,
+      Scope.Variable,
       {declarator: TSESTree.VariableDeclarator; node: TSESTree.CallExpression}
     >();
-    // Collected flagged usages per binding
-    const flaggedUsages = new Map<string, UsageInfo[]>();
-    // Number of references we've accounted for (flagged) per binding
-    const flaggedRefCount = new Map<string, number>();
+    // Collected flagged usages per Variable
+    const flaggedUsages = new Map<Scope.Variable, UsageInfo[]>();
+    // Number of references we've accounted for (flagged) per Variable
+    const flaggedRefCount = new Map<Scope.Variable, number>();
     // Local names imported from @sentry/scraps (these components are never memoized)
     const scrapsImports = new Set<string>();
+    // Names that are aliased imports of useCallback (e.g. `import {useCallback as uc}`)
+    const useCallbackNames = new Set(['useCallback']);
 
-    function addFlaggedUsage(name: string, usage: UsageInfo) {
-      let usages = flaggedUsages.get(name);
+    /**
+     * Resolve an Identifier node to its scope Variable, returning undefined
+     * if the variable cannot be found.
+     */
+    function resolveVariable(node: TSESTree.Identifier): Scope.Variable | undefined {
+      let scope = context.sourceCode.getScope(node);
+      while (scope) {
+        const variable = scope.variables.find(v => v.name === node.name);
+        if (variable) {
+          return variable;
+        }
+        scope = scope.upper!;
+      }
+      return undefined;
+    }
+
+    function addFlaggedUsage(variable: Scope.Variable, usage: UsageInfo) {
+      let usages = flaggedUsages.get(variable);
       if (!usages) {
         usages = [];
-        flaggedUsages.set(name, usages);
+        flaggedUsages.set(variable, usages);
       }
       usages.push(usage);
       flaggedRefCount.set(
-        name,
-        (flaggedRefCount.get(name) ?? 0) +
+        variable,
+        (flaggedRefCount.get(variable) ?? 0) +
           1 /* each usage accounts for one reference to the binding */
       );
     }
 
     /**
      * Walks an AST node looking for a CallExpression whose callee is a
-     * tracked useCallback binding. Returns the binding name if found.
+     * tracked useCallback binding. Returns the Variable if found.
      * Uses visitorKeys to avoid circular parent references.
      */
-    function findCallToBinding(node: TSESTree.Node): string | null {
+    function findCallToBinding(node: TSESTree.Node): Scope.Variable | null {
       if (
         node.type === AST_NODE_TYPES.CallExpression &&
-        node.callee.type === AST_NODE_TYPES.Identifier &&
-        useCallbackBindings.has(node.callee.name)
+        node.callee.type === AST_NODE_TYPES.Identifier
       ) {
-        return node.callee.name;
+        const variable = resolveVariable(node.callee);
+        if (variable && useCallbackBindings.has(variable)) {
+          return variable;
+        }
       }
       const keys = context.sourceCode.visitorKeys[node.type] ?? [];
       for (const key of keys) {
@@ -114,7 +135,25 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
     return {
       ImportDeclaration(node) {
         const source = node.source.value;
-        if (typeof source === 'string' && source.startsWith('@sentry/scraps')) {
+        if (typeof source !== 'string') {
+          return;
+        }
+
+        // Track aliased useCallback imports
+        if (source === 'react') {
+          for (const spec of node.specifiers) {
+            if (
+              spec.type === AST_NODE_TYPES.ImportSpecifier &&
+              spec.imported.type === AST_NODE_TYPES.Identifier &&
+              spec.imported.name === 'useCallback' &&
+              spec.local.name !== 'useCallback'
+            ) {
+              useCallbackNames.add(spec.local.name);
+            }
+          }
+        }
+
+        if (source.startsWith('@sentry/scraps')) {
           for (const spec of node.specifiers) {
             if (!scrapsExclusions.has(spec.local.name)) {
               scrapsImports.add(spec.local.name);
@@ -130,9 +169,12 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
         if (
           node.init?.type === AST_NODE_TYPES.CallExpression &&
           node.init.callee.type === AST_NODE_TYPES.Identifier &&
-          node.init.callee.name === 'useCallback'
+          useCallbackNames.has(node.init.callee.name)
         ) {
-          useCallbackBindings.set(node.id.name, {node: node.init, declarator: node});
+          const variable = resolveVariable(node.id);
+          if (variable) {
+            useCallbackBindings.set(variable, {node: node.init, declarator: node});
+          }
         }
       },
 
@@ -146,13 +188,12 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
         // Case 1: Arrow function that calls a useCallback binding in its body
         // e.g. onClick={() => fn()}, onClick={(e) => fn(e)},
         //      onClick={() => { fn(); doSomethingElse(); }}
-        // Case 1: Arrow function that calls a useCallback binding in its body
         // The arrow wrapper creates a new ref each render, defeating memoization.
         // The binding is referenced inside the arrow body — count as 1 reference.
         if (expr.type === AST_NODE_TYPES.ArrowFunctionExpression) {
-          const calledBinding = findCallToBinding(expr.body);
-          if (calledBinding) {
-            addFlaggedUsage(calledBinding, {
+          const calledVariable = findCallToBinding(expr.body);
+          if (calledVariable) {
+            addFlaggedUsage(calledVariable, {
               reason: 'directlyInvoked',
               line: node.value.loc.start.line,
             });
@@ -169,10 +210,12 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
 
         // Case 2: Direct reference on an unmemoized element — counts as 1 reference.
         // This includes intrinsic elements and components from @sentry/scraps.
-        if (
-          expr.type === AST_NODE_TYPES.Identifier &&
-          useCallbackBindings.has(expr.name)
-        ) {
+        if (expr.type === AST_NODE_TYPES.Identifier) {
+          const variable = resolveVariable(expr);
+          if (!variable || !useCallbackBindings.has(variable)) {
+            return;
+          }
+
           const openingElement = node.parent;
           if (openingElement.type !== AST_NODE_TYPES.JSXOpeningElement) {
             return;
@@ -184,13 +227,13 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
             tagName.type === AST_NODE_TYPES.JSXIdentifier &&
             tagName.name[0] === tagName.name[0]?.toLowerCase()
           ) {
-            addFlaggedUsage(expr.name, {
+            addFlaggedUsage(variable, {
               reason: 'intrinsicElement',
               element: tagName.name,
               line: node.value.loc.start.line,
             });
           } else if (elementName && scrapsImports.has(elementName)) {
-            addFlaggedUsage(expr.name, {
+            addFlaggedUsage(variable, {
               reason: 'unmemoizedComponent',
               element: elementName,
               line: node.value.loc.start.line,
@@ -200,8 +243,8 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
       },
 
       'Program:exit'() {
-        for (const [name, usages] of flaggedUsages) {
-          const binding = useCallbackBindings.get(name);
+        for (const [variable, usages] of flaggedUsages) {
+          const binding = useCallbackBindings.get(variable);
           if (!binding || binding.node.arguments.length === 0) {
             continue;
           }
@@ -209,18 +252,14 @@ export const noUnnecessaryUseCallback = ESLintUtils.RuleCreator.withoutDocs({
           // Count total references to this binding via scope analysis.
           // If there are references beyond the ones we flagged, the
           // useCallback may be justified (dep arrays, other hooks, etc.)
-          const scope = context.sourceCode.getScope(binding.declarator);
-          const variable = scope.variables.find(v => v.name === name);
-          // references includes the declaration itself, so subtract 1
-          const totalRefs = variable
-            ? variable.references.filter(r => r.isRead()).length
-            : 0;
-          const flagged = flaggedRefCount.get(name) ?? 0;
+          const totalRefs = variable.references.filter(r => r.isRead()).length;
+          const flagged = flaggedRefCount.get(variable) ?? 0;
 
           if (totalRefs > flagged) {
             continue;
           }
 
+          const name = variable.name;
           const callNode = binding.node;
           const firstArg = callNode.arguments[0];
           const callbackText = context.sourceCode.getText(firstArg);