Reading Other People's Code

How to read a project's folder structure without getting lost

root directory layout, src vs lib vs dist, entry points, config files, README as a map, monorepo vs single-repo

What package.json and dependency files tell you about a project

dependencies vs devDependencies, version pinning, scripts block, peer dependencies, lockfiles, tech stack inference

How to find the entry point of any application

Node.js main field, Python __main__, Java main method, web app index.html, framework conventions, CLI entry points

How to use git log and git blame to understand code history

git log flags, git blame output, commit message quality, finding when a bug was introduced, git bisect overview, reading diffs

How to run an unfamiliar project locally in under 10 minutes

README quickstart, environment variables, .env.example pattern, dependency installation, common setup failures, Docker as fallback

How to read a function without running it

function signature reading, parameter types and names, return type inference, side effects vs pure functions, default parameters, destructuring in signatures

How to trace data flow through a function call chain

call stack tracing, argument passing, return value propagation, intermediate variables, function composition, callback chains, async/await tracing

What naming conventions tell you about a codebase's intent

camelCase vs snake_case, is/has/get/set prefixes, Hungarian notation remnants, private underscore prefix, ALL_CAPS constants, file naming conventions

How to read and understand code comments and documentation

JSDoc/docstring format, inline comment purpose, TODO and FIXME markers, comment rot, why vs what comments, API documentation headers

How to annotate unfamiliar code to understand it faster

rubber duck annotation, incremental commenting, scratch files, hypothesis-driven reading, annotation tools, when to delete annotations

How to use grep and IDE search to find code fast

grep flags, ripgrep advantages, find by symbol vs text, case sensitivity, regex in search, searching inside node_modules, IDE go-to-definition

How to understand module architecture from import statements

import graph reading, circular dependency detection, absolute vs relative imports, index barrel files, understanding coupling, dependency direction

How to read tests to understand what code is supposed to do

test file location, describe/it block naming, arrange-act-assert pattern, what tests reveal about API, reading test data, edge cases in tests

How to map a codebase using a call graph

call graph concept, building manual call graphs, automated call graph tools, finding dead code, hotspot identification, reading breadth-first vs depth-first

How to read a design pattern you didn't write

recognizing common patterns, Observer pattern, Factory pattern, Singleton, Repository pattern, Middleware pattern, when patterns become anti-patterns

How to read an error message and find where the bug actually is

stack trace anatomy, reading line numbers, finding the application frame vs library frame, error types, message vs cause distinction, nested errors

How to use console.log strategically when debugging unfamiliar code

strategic log placement, logging intermediate values, console.log vs console.dir vs console.table, removing debug logs, structured logging, log levels

How to use a debugger to step through unfamiliar code

breakpoints, step over vs step into vs step out, watch expressions, call stack panel, conditional breakpoints, VS Code debugger setup

How to form and test a hypothesis when debugging unknown code

scientific debugging method, hypothesis formation, minimal reproducible example, binary search debugging, rubber duck debugging, documenting findings

How to read logs and identify patterns in production errors

structured log format, log levels, timestamp reading, correlation IDs, identifying error frequency, log aggregation tools overview, reading JSON logs

How to assess the blast radius before changing any code

blast radius concept, finding all callers, checking shared utilities, database migration risk, interface vs implementation changes, backward compatibility

How to match the coding style of a codebase you're contributing to

reading .eslintrc and .prettierrc, inferring style from existing code, naming convention consistency, error handling patterns, async patterns, test structure matching

How to write tests for code you didn't write

testing existing behavior, characterization tests, finding test boundaries, mocking dependencies you don't own, test doubles, testing edge cases in legacy code

How to write a good pull request description for unfamiliar code

PR description structure, explaining why not what, blast radius documentation, testing evidence, migration notes, reviewer guidance, screenshots for UI changes

How to refactor code you didn't write without breaking it

refactoring vs rewriting, small safe steps, test-first refactoring, rename → extract → move sequence, preserving behavior, when not to refactor

How to read a git diff without getting confused

unified diff format, hunk headers, added vs removed lines, context lines, file headers, binary files in diffs, reading large diffs strategically

What to actually look for when reviewing someone's code

correctness over style, logic errors, edge case coverage, security implications, performance implications, error handling completeness, test quality

How to give code review feedback that developers actually use

comment types (blocker vs suggestion vs nit), asking questions vs making demands, explaining why, requesting vs mandating, positive feedback, async review etiquette

How to review code changes that touch areas you don't know

reading outside your expertise, asking about unfamiliar decisions, verifying tests cover intent, flagging for domain expert review, learning from reviews, honest uncertainty

How to receive and apply code review feedback effectively

separating code from identity, clarifying before changing, resolving vs closing comments, when to push back, applying feedback without losing intent, follow-up PR pattern