Continuous Integration

Checking that people using screen readers, keyboards, magnification, or other assistive technology can actually use an interface, through a mix of automated scans and hands-on testing.

Bots that open pull requests whenever a dependency releases a new version, how they keep upgrades small and security patches fast, and how they turn into noise or a supply-chain risk when misconfigured.

Measuring how fast code runs under controlled conditions, which is far harder to do honestly than it looks.

Server-side rules that stop people from pushing straight to important branches, requiring reviews, passing checks, and intact history instead.

The convention governing what branches exist, what they mean, and how work reaches production.

Reusing the outputs of build and test steps whose inputs haven't changed, keyed by a hash of those inputs, so large codebases build in minutes instead of hours.

A short written list of critical steps checked at a set moment, which aviation adopted after a 1935 crash and surgery after a 2009 study cut deaths by more than a third, because experts skip steps under pressure, not from ignorance.

A tool that rewrites source code into one canonical layout automatically, ending style debates in code review and keeping diffs focused on what changed.

Automatically releasing every change that passes validation.

Verifying that a service and its consumer agree on an interface's shape, without either side needing the other running to test against.

A build check that fails when coverage falls below a threshold, and what that pressure produces.

A team's shared checklist of what must be true before work counts as finished, such as reviewed, tested, documented, and deployed, which keeps hidden work from piling up behind items marked complete.

The Git state in which the current checkout points directly at a commit rather than a branch, harmless for looking around but a trap for new work, since commits made there belong to no branch and can quietly disappear.

Documentation that has drifted from the system it describes, and is now worse than none.

A branch created to develop one change in isolation before merging it back, a workflow that keeps the main line stable but grows riskier the longer the branch lives, since its divergence from everyone else's work compounds.

A runtime switch that decouples shipping code from enabling behavior.

Finding the commit that introduced a bug by binary search through history, testing the midpoint between a known-good and a known-bad version until one commit remains.

Scripts Git runs automatically at points such as committing or pushing, used to check formatting and messages locally, and on servers to enforce policy or trigger deploys.

A Git extension that stores large binary files on a separate server and keeps small pointer files in the repository, so history stays light enough to clone.

The time spent debating an item is inversely proportional to its actual stakes.

Overlapping changes that a merge cannot combine automatically, requiring a decision.

Validating changes against the state they will actually merge into, in order, rather than in isolation.

A committed numeric ceiling on a page's cost, enforced automatically.

A proposal to merge a branch, carrying review, automated checks, and the discussion around it.

Replaying a branch's commits onto a new base, producing new commits with the same changes.

Rerunning existing tests after every change to confirm that what used to work still works, how the suite grows one fixed bug at a time, and how teams keep it fast enough to run.

Failures caused by competition for a finite shared resource rather than by any defect.

Two changes that merge cleanly and are incompatible in meaning.

Ways to fetch less than a whole Git repository, by cutting history, deferring file contents, or checking out only some directories, and what each breaks.

A chain of dependent changes, each reviewed separately and merged in order.

The intermediate snapshot in Git between the working files and the next commit, which lets a developer choose exactly which changes go into each commit, down to individual lines.

Finding bugs by examining code without running it, from linters and type checkers to deep security analysis, always trading missed bugs against false alarms.

Running only the tests a change could plausibly affect, using dependency graphs, coverage maps, or learned models, so large suites stay fast without giving up their safety net.

Combining two lines of work by comparing both against their common ancestor.

Everyone integrating into one shared branch continuously, with short-lived feature branches.

A statement that holds only because its subject set is empty — a green result that measured nothing.