liveBook · Manning

Maintainability

As explained in "Looks Good to Me"

Code maintainability is the ease with which software code can be understood, modified, debugged, and extended safely.

Code maintainability is the capacity of a codebase to remain clear, readable, stable, understandable, and safe to modify. Human-centered code reviews improve maintainability by catching ambiguity, encouraging human-friendly code, and reducing future debugging effort, defects, and maintenance cost. section 1.3.1 section 3.1.2

Make maintainability a deliberate code-review goal by checking:

  • Complexity, consistency, scalability, coding conventions, team standards, and code smells. section 3.1.2
  • Accompanying unit tests, relevant edge cases, and how each isolated change fits into the larger system. section 3.1.2
  • Team agreement about what maintainability means, since the definition and priorities differ across teams. section 3.1.2
  • Review coverage and participation, because omitted or laxly reviewed changes allow defect-prone code to reach releases. section 1.3.1

A maintainability-focused review process

Start by making codebase stability and maintainability the team’s first review goal. Reinforce practices that improve it, remove bottlenecks and counterproductive actions, and iterate until the behaviors become routine. Later, add recordkeeping by improving pull-request preparation, categorizing titles, using labels and links, and recording meaningful context. When reviewers disagree about clarity, keep the discussion professional, explain the reasoning behind each approach, seek middle ground, and choose the solution that makes sense to current and future developers. section 3.1.6 section 6.1.1

Figure 3.1 Choosing code review goals for your team
figure

Use the decision figure to compare code-review goals and prioritize stability and maintainability when establishing a new process. section 3.1.6

How "Looks Good to Me" covers it

How deep it goes
Defines practical review criteria and improvement steps, but stops short of code-level implementation internals.
Examples
Uses code reviews, unit tests, edge-case checks, coding conventions, code-smell detection, and pull-request context as concrete practices.
What it assumes
Assumes collaborative code review and team standards, while teaching teams to establish goals and refine practices together.
What you can do after
Apply it through a team code-review process by prioritizing stability, iterating practices, and resolving disagreements toward maintainable solutions.
How it connects
Ties maintainability to code reviews, readability, code quality, debugging, extensibility, testing, code smells, and team standards.

Also explained in

Compare how 7 books explain maintainability →

Related concepts

This explainer was generated by Manning's knowledge graph from the text of "Looks Good to Me". The section links point to the parts of the book it draws on.