Heuristics for analyzing a codebase to extract reliable, user-facing documentation. This file contains technique checklists only—no tool instructions or invocations. Find and analyze UI components and their interactions Start from feature or route directories and enumerate components related to the requested topic. Differentiate container vs presentational components; note composition patterns. Trace inputs/outputs: props, state, context, events, and side effects. Record conditional rendering that affects user-visible states. Primary components and responsibilities. Props/state/context that change behavior. High-level dependency/composition map. Analyze styling and visual elements Identify design tokens and utility classes used to drive layout and state. Capture responsive behavior and breakpoint rules that materially change UX. Document visual affordances tied to state (loading, error, disabled). Key classes/selectors influencing layout/state. Responsive behavior summary and breakpoints. Map user interactions and navigation flows Route definitions and navigation Form submissions and validations Button clicks and event handlers State changes and UI updates Loading and error states Outline entry points and expected outcomes for each primary flow. Summarize validation rules and failure states the user can encounter. Record redirects and deep-link behavior relevant to the feature. Flow diagrams or bullet sequences for main tasks. Validation conditions and error messages. Navigation transitions and guards. Analyze how the system communicates with users Error messages and alerts Success notifications Loading indicators Tooltips and help text Confirmation dialogs Progress indicators Map message triggers to the user actions that cause them. Capture severity, persistence, and dismissal behavior. Note localization or accessibility considerations in messages. Catalog of messages with purpose and conditions. Loading/progress patterns and timeouts. Check for accessibility features and compliance ARIA labels and roles Keyboard navigation support Screen reader compatibility Focus management Color contrast considerations Confirm interactive elements have clear focus and labels. Describe keyboard-only navigation paths for core flows. Accessibility gaps affecting task completion. Analyze responsive design and mobile experience Breakpoint definitions Mobile-specific components Touch event handlers Viewport configurations Media queries Summarize layout changes across breakpoints that alter workflow. Note touch targets and gestures required on mobile. Table of key differences per breakpoint. Understand feature entry points and control flow Identify main functions, controllers, or route handlers. Trace execution and decision branches. Document input validation and preconditions. Entry points list and short purpose statements. Decision matrix or flow sketch. Extract API specifications from code HTTP method and route path Path/query parameters Request/response schemas Status codes and error bodies Schema and input types Resolvers and return types Field arguments and constraints Map dependencies and integration points Imports and module boundaries Package and runtime dependencies External API/SDK usage DB connections and migrations Messaging/queue/event streams Filesystem or network side effects Dependency graph summary and hot spots. List of external integrations and auth methods. Extract data models, schemas, and type definitions - interfaces, types, classes, enums - Schema definitions, migration files, ORM models - JSON Schema, Joi/Yup/Zod schemas, validation decorators Canonical definitions and field constraints. Entity relationships and ownership. Identify and document business rules Complex conditionals Calculation functions Validation rules State machines Domain-specific constants and algorithms Why the logic exists (business need) When the logic applies (conditions) What the logic does (transformation) Edge cases and invariants Impact of changes Document error handling and recovery try/catch blocks and error boundaries Custom error classes and codes Logging, fallbacks, retries, circuit breakers Error taxonomy and user-facing messages. Recovery/rollback strategies and timeouts. Identify security measures and vulnerabilities JWT, sessions, OAuth, API keys RBAC, permission checks, ownership validation Encryption, hashing, sensitive data handling Sanitization and injection prevention Threat surfaces and mitigations relevant to the feature. Identify performance factors and optimization opportunities Expensive loops/algorithms DB query patterns (e.g., N+1) Caching strategies Concurrency and async usage Batching and resource pooling Memory management and object lifetimes Time/space complexity DB query counts API response times Memory usage Concurrency handling Assess test coverage at a useful granularity Function-level coverage and edge cases Workflow coverage and contract boundaries Endpoint success/failure paths and schemas List of critical behaviors missing tests. Extract configuration options and their impacts .env files, config files, CLI args, feature flags Default values and valid ranges Behavioral impact of each option Dependencies between options Security implications Map user workflows through the feature Identify entry points (UI, API, CLI) Trace user actions and decision points Map data transformations Identify outcomes and completion criteria Flow diagrams, procedures, decision trees, state diagrams Document integration with other systems Sync API calls, async messaging, events, batch processing, streaming Protocols, auth, error handling, data transforms, SLAs Summarize version constraints and compatibility package manifests, READMEs, migration guides, breaking changes docs Minimum/recommended versions and notable constraints. Track deprecations and migrations Explicit deprecation notices and TODO markers Legacy code paths and adapters Deprecation date and removal timeline Migration path and alternatives Public APIs documented with inputs/outputs and errors Examples for complex features Error scenarios covered with recovery guidance Config options explained with defaults and impacts Security considerations addressed Cyclomatic complexity Code duplication Test coverage and gaps Documentation coverage for user-visible behaviors Known technical debt affecting UX