discord-manager: Skill for Claude Code

Type Safety

Everything here documents the repository as it is on main. If main disagrees with this file, main wins: follow it and flag the drift.

TypeScript runs in strict mode and any is not allowed anywhere. Lean on inference: add an annotation only when removing it would lose type safety or cause a compile error. Before adding one, ask whether TypeScript would infer the correct type without it.

Return types

Do not add return types. TypeScript infers them from the body.

// correct
async function fetchBookmarks() {
  const rows = await db().selectFrom('bookmarkAdditions').selectAll().execute()
  return rows
}

// wrong — redundant return type
async function fetchBookmarks(): Promise<BookmarkRow[]> {
  const rows = await db().selectFrom('bookmarkAdditions').selectAll().execute()
  return rows
}

Exceptions where a return type is required

• Interface implementations — when a method must satisfy a library interface, such as Kysely's MigrationProvider
• Non-async functions returning promises — without async, TypeScript can infer a more complex type than intended

Variable annotations

Do not annotate a variable whose type is obvious from the right-hand side.

// correct
const threshold = 15

// wrong — redundant
const threshold: number = 15

Empty collections need annotations

TypeScript cannot infer the element type of an empty literal. Annotate empty arrays and objects that get populated later.

const skippedChannelIds: string[] = []

const grouped = channelIds.reduce<Record<string, string[]>>(
  (groups, id) => ({ ...groups, [id]: [] }),
  {},
)

Map constants

A constant object indexed with a dynamic string key needs an explicit index type; otherwise TypeScript infers a literal object type that rejects arbitrary string indexing.

Copy maps keyed by a closed reason union are the opposite case: type them with satisfies Record<Reason, Guidance> so the map stays exhaustive and a new reason fails to compile until it has copy. Load integration-telemetry for what those maps hold.