diff --git a/apps/dashboard/src/components/layouts/dashboard-topbar.tsx b/apps/dashboard/src/components/layouts/dashboard-topbar.tsx
index 443d8bd..e423b30 100644
--- a/apps/dashboard/src/components/layouts/dashboard-topbar.tsx
+++ b/apps/dashboard/src/components/layouts/dashboard-topbar.tsx
@@ -26,6 +26,7 @@ import { useTheme } from "next-themes";
 import { useCallback, useEffect, useRef, useState } from "react";
 import { signOutToLogin } from "#/lib/auth-actions";
 import { preloadRouteOnce } from "#/lib/route-preload";
+import { useGlobalShortcuts } from "#/lib/shortcuts";
 import { removeTab, type Tab, useTabs } from "#/lib/tab-store";
 
 interface DashboardTopbarProps {
@@ -62,6 +63,7 @@ const tabIconMap = {
 } as const;
 
 const primaryNavRoutes = ["/", "/pulls", "/issues", "/reviews"] as const;
+const MAX_TAB_SHORTCUTS = 9;
 
 export function DashboardTopbar({
 	user,
@@ -144,6 +146,50 @@ export function DashboardTopbar({
 		);
 	}, [router, tabsReady, openTabs]);
 
+	function navigateToTab(tab: Tab | undefined) {
+		if (!tab) return;
+		void router.navigate({ to: tab.url });
+	}
+
+	useGlobalShortcuts([
+		...Array.from(
+			{ length: Math.min(openTabs.length, MAX_TAB_SHORTCUTS) },
+			(_, index) => ({
+				shortcut: { code: `Digit${index + 1}`, shift: true },
+				enabled: tabsReady,
+				onTrigger: () => {
+					navigateToTab(openTabs[index]);
+				},
+			}),
+		),
+		{
+			shortcut: { key: "ArrowLeft", shift: true },
+			enabled: tabsReady && openTabs.length > 1,
+			onTrigger: () => {
+				const currentIndex = openTabs.findIndex(
+					(tab) => tab.url === router.state.location.pathname,
+				);
+				const nextIndex =
+					currentIndex === -1
+						? openTabs.length - 1
+						: (currentIndex - 1 + openTabs.length) % openTabs.length;
+				navigateToTab(openTabs[nextIndex]);
+			},
+		},
+		{
+			shortcut: { key: "ArrowRight", shift: true },
+			enabled: tabsReady && openTabs.length > 1,
+			onTrigger: () => {
+				const currentIndex = openTabs.findIndex(
+					(tab) => tab.url === router.state.location.pathname,
+				);
+				const nextIndex =
+					currentIndex === -1 ? 0 : (currentIndex + 1) % openTabs.length;
+				navigateToTab(openTabs[nextIndex]);
+			},
+		},
+	]);
+
 	return (
 		<nav className="flex min-w-0 items-center gap-3 overflow-hidden px-3 py-2">
 			<DropdownMenu>
diff --git a/apps/dashboard/src/components/pulls/detail/pull-body-section.tsx b/apps/dashboard/src/components/pulls/detail/pull-body-section.tsx
index 2fa9636..0b2e03e 100644
--- a/apps/dashboard/src/components/pulls/detail/pull-body-section.tsx
+++ b/apps/dashboard/src/components/pulls/detail/pull-body-section.tsx
@@ -23,6 +23,7 @@ import { useCallback, useEffect, useRef, useState } from "react";
 import { updatePullBody } from "#/lib/github.functions";
 import { type GitHubQueryScope, githubQueryKeys } from "#/lib/github.query";
 import type { PullDetail, PullPageData } from "#/lib/github.types";
+import { matchesShortcut } from "#/lib/shortcuts";
 import { useOptimisticMutation } from "#/lib/use-optimistic-mutation";
 
 export function PullBodySection({
@@ -68,36 +69,47 @@ export function PullBodySection({
 
 	const handleEditorKeyDown = useCallback(
 		(event: React.KeyboardEvent<HTMLTextAreaElement>) => {
-			const mod = event.metaKey || event.ctrlKey;
-			if (!mod) return;
+			const action = [
+				{
+					shortcut: { key: "b", mod: true },
+					run: () => insertMarkdown("**", "**", "bold"),
+				},
+				{
+					shortcut: { key: "i", mod: true },
+					run: () => insertMarkdown("_", "_", "italic"),
+				},
+				{
+					shortcut: { key: "e", mod: true },
+					run: () => insertMarkdown("`", "`", "code"),
+				},
+				{
+					shortcut: { key: "k", mod: true },
+					run: () => insertMarkdown("[", "](url)", "text"),
+				},
+				{
+					shortcut: { key: "h", mod: true },
+					run: () => insertMarkdown("### ", "", "heading"),
+				},
+				{
+					shortcut: { key: ".", mod: true, shift: true },
+					run: () => insertMarkdown("> ", "", "quote"),
+				},
+				{
+					shortcut: { key: "8", mod: true, shift: true },
+					run: () => insertMarkdown("- ", "", "item"),
+				},
+				{
+					shortcut: { key: "7", mod: true, shift: true },
+					run: () => insertMarkdown("1. ", "", "item"),
+				},
+			].find(({ shortcut }) => matchesShortcut(event, shortcut));
 
-			const shortcuts: Record<string, () => void> = {
-				b: () => insertMarkdown("**", "**", "bold"),
-				i: () => insertMarkdown("_", "_", "italic"),
-				e: () => insertMarkdown("`", "`", "code"),
-				k: () => insertMarkdown("[", "](url)", "text"),
-				h: () => insertMarkdown("### ", "", "heading"),
-			};
-
-			if (event.shiftKey) {
-				const shiftShortcuts: Record<string, () => void> = {
-					".": () => insertMarkdown("> ", "", "quote"),
-					"8": () => insertMarkdown("- ", "", "item"),
-					"7": () => insertMarkdown("1. ", "", "item"),
-				};
-				const action = shiftShortcuts[event.key];
-				if (action) {
-					event.preventDefault();
-					action();
-				}
+			if (!action) {
 				return;
 			}
 
-			const action = shortcuts[event.key];
-			if (action) {
-				event.preventDefault();
-				action();
-			}
+			event.preventDefault();
+			action.run();
 		},
 		[insertMarkdown],
 	);
diff --git a/apps/dashboard/src/lib/command-palette/use-command-palette.ts b/apps/dashboard/src/lib/command-palette/use-command-palette.ts
index 054da2d..2283fbd 100644
--- a/apps/dashboard/src/lib/command-palette/use-command-palette.ts
+++ b/apps/dashboard/src/lib/command-palette/use-command-palette.ts
@@ -1,78 +1,37 @@
 import { useRouter } from "@tanstack/react-router";
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useState } from "react";
+import { useGlobalShortcuts } from "#/lib/shortcuts";
 import { getRegisteredCommands } from "./registry";
 
-const CHORD_TIMEOUT_MS = 800;
-
-function isEditableTarget(e: KeyboardEvent) {
-	const tag = (e.target as HTMLElement)?.tagName;
-	if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return true;
-	if ((e.target as HTMLElement)?.isContentEditable) return true;
-	return false;
-}
-
 export function useCommandPalette() {
 	const [open, setOpen] = useState(false);
 	const router = useRouter();
-	const chordRef = useRef<string[]>([]);
-	const chordTimerRef = useRef<ReturnType<typeof setTimeout>>(undefined);
-
-	useEffect(() => {
-		function resetChord() {
-			chordRef.current = [];
-			clearTimeout(chordTimerRef.current);
-		}
 
-		function onKeyDown(e: KeyboardEvent) {
-			if (e.key === "k" && (e.metaKey || e.ctrlKey)) {
-				e.preventDefault();
-				resetChord();
+	useGlobalShortcuts([
+		{
+			shortcut: { key: "k", mod: true },
+			allowInEditable: true,
+			onTrigger: () => {
 				setOpen((prev) => !prev);
-				return;
-			}
-
-			if (open || e.metaKey || e.ctrlKey || e.altKey || isEditableTarget(e)) {
-				return;
-			}
-
-			const key = e.key.toUpperCase();
-			if (key.length !== 1 || !/[A-Z]/.test(key)) {
-				resetChord();
-				return;
-			}
-
-			chordRef.current = [...chordRef.current, key];
-			clearTimeout(chordTimerRef.current);
-			chordTimerRef.current = setTimeout(resetChord, CHORD_TIMEOUT_MS);
-
-			const pressed = chordRef.current;
-			const commands = getRegisteredCommands();
-
-			for (const cmd of commands) {
-				if (!cmd.shortcut) continue;
-				const shortcut = cmd.shortcut.map((k) => k.toUpperCase());
-
-				if (shortcut.length !== pressed.length) continue;
-				if (!shortcut.every((k, i) => k === pressed[i])) continue;
-
-				e.preventDefault();
-				resetChord();
-
-				if (cmd.action.type === "navigate") {
-					void router.navigate({ to: cmd.action.to });
-				} else {
-					void cmd.action.fn();
-				}
-				return;
-			}
-		}
-
-		document.addEventListener("keydown", onKeyDown);
-		return () => {
-			document.removeEventListener("keydown", onKeyDown);
-			clearTimeout(chordTimerRef.current);
-		};
-	}, [open, router]);
+			},
+		},
+		...getRegisteredCommands().flatMap((cmd) => {
+			if (!cmd.shortcut) return [];
+			return [
+				{
+					shortcut: cmd.shortcut.map((key) => ({ key })),
+					enabled: !open,
+					onTrigger: () => {
+						if (cmd.action.type === "navigate") {
+							void router.navigate({ to: cmd.action.to });
+						} else {
+							void cmd.action.fn();
+						}
+					},
+				},
+			];
+		}),
+	]);
 
 	const close = useCallback(() => setOpen(false), []);
 
diff --git a/apps/dashboard/src/lib/shortcuts.ts b/apps/dashboard/src/lib/shortcuts.ts
new file mode 100644
index 0000000..679584d
--- /dev/null
+++ b/apps/dashboard/src/lib/shortcuts.ts
@@ -0,0 +1,235 @@
+import { useEffect, useEffectEvent, useRef } from "react";
+
+type KeyboardEventSource = Pick<
+	KeyboardEvent,
+	"altKey" | "code" | "ctrlKey" | "key" | "metaKey" | "shiftKey"
+>;
+
+export type ShortcutStep = {
+	key?: string;
+	code?: string;
+	shift?: boolean;
+	alt?: boolean;
+	ctrl?: boolean;
+	meta?: boolean;
+	mod?: boolean;
+};
+
+export type ShortcutDefinition = {
+	shortcut: ShortcutStep | ShortcutStep[];
+	onTrigger: (event: KeyboardEvent) => void;
+	enabled?: boolean;
+	allowInEditable?: boolean;
+	preventDefault?: boolean;
+	stopPropagation?: boolean;
+};
+
+const SEQUENCE_TIMEOUT_MS = 800;
+
+type KeyboardEventSnapshot = KeyboardEventSource;
+
+function normalizeShortcut(shortcut: ShortcutDefinition["shortcut"]) {
+	return Array.isArray(shortcut) ? shortcut : [shortcut];
+}
+
+function toSnapshot(event: KeyboardEvent): KeyboardEventSnapshot {
+	return {
+		key: event.key,
+		code: event.code,
+		shiftKey: event.shiftKey,
+		altKey: event.altKey,
+		ctrlKey: event.ctrlKey,
+		metaKey: event.metaKey,
+	};
+}
+
+export function isEditableKeyboardTarget(target: EventTarget | null) {
+	const element = target as HTMLElement | null;
+	const tag = element?.tagName;
+	if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return true;
+	return element?.isContentEditable ?? false;
+}
+
+export function matchesShortcut(
+	event: KeyboardEventSource,
+	shortcut: ShortcutStep,
+) {
+	if (shortcut.key && event.key.toLowerCase() !== shortcut.key.toLowerCase()) {
+		return false;
+	}
+
+	if (shortcut.code && event.code !== shortcut.code) {
+		return false;
+	}
+
+	if (event.shiftKey !== (shortcut.shift ?? false)) {
+		return false;
+	}
+
+	if (event.altKey !== (shortcut.alt ?? false)) {
+		return false;
+	}
+
+	if (shortcut.mod != null) {
+		if ((event.metaKey || event.ctrlKey) !== shortcut.mod) {
+			return false;
+		}
+	} else {
+		if (event.metaKey !== (shortcut.meta ?? false)) {
+			return false;
+		}
+
+		if (event.ctrlKey !== (shortcut.ctrl ?? false)) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+function sequenceStartsWith(
+	events: KeyboardEventSnapshot[],
+	shortcut: ShortcutStep[],
+) {
+	if (events.length > shortcut.length) return false;
+	return events.every((event, index) =>
+		matchesShortcut(event, shortcut[index]),
+	);
+}
+
+function findMatchingShortcut(
+	shortcuts: ShortcutDefinition[],
+	event: KeyboardEvent,
+	editable: boolean,
+) {
+	for (const definition of shortcuts) {
+		if (definition.enabled === false) continue;
+		if (editable && !definition.allowInEditable) continue;
+		const steps = normalizeShortcut(definition.shortcut);
+		if (steps.length !== 1) continue;
+		if (matchesShortcut(event, steps[0])) {
+			return definition;
+		}
+	}
+
+	return null;
+}
+
+function findMatchingSequence(
+	shortcuts: ShortcutDefinition[],
+	events: KeyboardEventSnapshot[],
+	editable: boolean,
+) {
+	for (const definition of shortcuts) {
+		if (definition.enabled === false) continue;
+		if (editable && !definition.allowInEditable) continue;
+		const steps = normalizeShortcut(definition.shortcut);
+		if (steps.length <= 1) continue;
+		if (events.length !== steps.length) continue;
+		if (sequenceStartsWith(events, steps)) {
+			return definition;
+		}
+	}
+
+	return null;
+}
+
+function hasSequencePrefix(
+	shortcuts: ShortcutDefinition[],
+	events: KeyboardEventSnapshot[],
+	editable: boolean,
+) {
+	for (const definition of shortcuts) {
+		if (definition.enabled === false) continue;
+		if (editable && !definition.allowInEditable) continue;
+		const steps = normalizeShortcut(definition.shortcut);
+		if (steps.length <= 1) continue;
+		if (sequenceStartsWith(events, steps)) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+export function useGlobalShortcuts(shortcuts: ShortcutDefinition[]) {
+	const sequenceRef = useRef<KeyboardEventSnapshot[]>([]);
+	const sequenceTimerRef = useRef<ReturnType<typeof setTimeout>>(undefined);
+
+	const resetSequence = useEffectEvent(() => {
+		sequenceRef.current = [];
+		clearTimeout(sequenceTimerRef.current);
+	});
+
+	const handleKeyDown = useEffectEvent((event: KeyboardEvent) => {
+		const editable = isEditableKeyboardTarget(event.target);
+		const singleShortcut = findMatchingShortcut(shortcuts, event, editable);
+
+		if (singleShortcut) {
+			if (singleShortcut.preventDefault !== false) {
+				event.preventDefault();
+			}
+			if (singleShortcut.stopPropagation) {
+				event.stopPropagation();
+			}
+			resetSequence();
+			singleShortcut.onTrigger(event);
+			return;
+		}
+
+		const sequenceShortcuts = shortcuts.filter(
+			(definition) =>
+				definition.enabled !== false &&
+				normalizeShortcut(definition.shortcut).length > 1,
+		);
+		if (sequenceShortcuts.length === 0) {
+			resetSequence();
+			return;
+		}
+
+		const nextEvent = toSnapshot(event);
+		const nextSequence = [...sequenceRef.current, nextEvent];
+
+		clearTimeout(sequenceTimerRef.current);
+
+		const matchedSequence = findMatchingSequence(
+			sequenceShortcuts,
+			nextSequence,
+			editable,
+		);
+		if (matchedSequence) {
+			if (matchedSequence.preventDefault !== false) {
+				event.preventDefault();
+			}
+			if (matchedSequence.stopPropagation) {
+				event.stopPropagation();
+			}
+			resetSequence();
+			matchedSequence.onTrigger(event);
+			return;
+		}
+
+		if (hasSequencePrefix(sequenceShortcuts, nextSequence, editable)) {
+			sequenceRef.current = nextSequence;
+			sequenceTimerRef.current = setTimeout(resetSequence, SEQUENCE_TIMEOUT_MS);
+			return;
+		}
+
+		const fallbackSequence = [nextEvent];
+		if (hasSequencePrefix(sequenceShortcuts, fallbackSequence, editable)) {
+			sequenceRef.current = fallbackSequence;
+			sequenceTimerRef.current = setTimeout(resetSequence, SEQUENCE_TIMEOUT_MS);
+			return;
+		}
+
+		resetSequence();
+	});
+
+	useEffect(() => {
+		document.addEventListener("keydown", handleKeyDown);
+		return () => {
+			document.removeEventListener("keydown", handleKeyDown);
+			clearTimeout(sequenceTimerRef.current);
+		};
+	}, []);
+}