Continuous Integration

The last topic ended on a one-word fix for integration hell: do it continuously. Continuous integration — almost always shortened to CI — means every change is merged back into the shared code and automatically checked, many times a day, while each change is still small. No waiting for a dreaded merge event; the merging and the checking happen constantly, in the background, on every commit.

Picture Maya saving a small commit to Pageturn. The instant she does, a machine springs into action: it assembles the app from the latest code, runs the app's tests, and reports back within minutes whether anything broke. She finds out her change is healthy — or that it isn't — while the work is still fresh in her mind. That fast, automatic check on every change is the whole idea, and here is what it looks like.

What continuous integration means

CI is two ideas welded together: integrate, and check — automatically, on every change. The integrate half is from the last topic: each small commit folds back into the shared code right away instead of piling up. The check half is new: a machine doesn't just accept the change, it immediately tries to build and test the app with that change included, and only then declares it healthy or broken.

The key word is automatically. No one remembers to run the checks, and no one can skip them when they're in a hurry. Every single change gets the same treatment, every time — which is exactly the consistency that hand-run steps could never guarantee.

What runs on every change

This is the pipeline idea from Chapter 2, pointed at integration. When a commit lands, an automated sequence runs in a fixed order: first build the app — assemble it from the latest code to confirm the pieces still fit — then run the tests, then report a single verdict, pass or fail. If the build or the tests fail, the line stops and Maya is told; nothing broken is allowed to slip quietly into the shared code.

Teams describe that sequence in a small text file that lives alongside the code, and the machine follows it. Here is a stripped-down example for Pageturn. It says: on every push of a change, run a job that has a few steps — install the tools the app depends on, build the app, and run the tests. That's the entire shape of it — a trigger at the top, then a short list of steps to run in order. You don't need to read it as code; the words in it are the same build-and-test steps the prose just described. You'll write real files like this yourself in the Git, GitHub & GitHub Actions course — here it's only an exhibit, to make the artifact concrete.

on: push
jobs:
  test:
    steps:
      - run: install dependencies
      - run: build the app
      - run: run the tests

Why fast feedback changes everything

The payoff is speed of discovery. Because the check runs the moment a change is made, a problem is caught minutes after it's created — while the change is small, recent, and the only thing that could have caused it. Maya doesn't have to hunt; the break points straight at the few lines she just touched.

Compare that to finding the same bug weeks later, mixed in with hundreds of other changes. A problem caught early is cheap to fix; the same problem caught late is expensive, because it's buried and because work has piled on top of it. Tightening that gap from weeks to minutes is the entire reason CI is worth the setup.

What CI is not

One careful distinction, because it trips up almost everyone: CI checks a change, but it does not ship it to users. Building and testing Pageturn on every commit tells the team the change is healthy — actually releasing that change to readers is a separate practice called continuous delivery, the subject of Chapter 8. CI is the gate; delivery is the door.

Nor does CI replace the human review from Chapter 3. The machine checks that the code builds and the tests pass; a teammate still reads the change for judgment a test can't capture. The two run side by side. When you reach the Git, GitHub & GitHub Actions course, the file above is exactly the kind of thing you'll write to set this gate up for real.