Six services, each one a different mark in the margin.

A Close Reading Systems Audit is the foundational service of the practice. We take a system in its entirety, including its source code, its infrastructure definitions, its external contracts, its runbooks and the informal knowledge that lives in chat threads and overflow notes, and we read all of it in order, beginning to end, the way a scholar reads a difficult manuscript. Nothing is skimmed. Nothing is sampled. Every claim the system makes about itself is checked against what the system actually does.

The audit produces an annotated copy of your system in which every ambiguity, every stale assumption and every undocumented dependency is marked at the line where it lives. You receive a summary of findings arranged by risk, but the true product is the marginal record itself, written for the engineer who will one day open these files without the original authors present. We commonly find that the most valuable notes are the ones explaining why a piece of code exists at all, a fact that too often survives only in memory.

Audits are scoped by the size of the reading rather than by hours. A single service may be read in a week, while an interconnected platform of a dozen services and three hardware integrations may occupy a full season. We tell you at the outset how many pages we expect to turn and what we intend to look for, so that there are no surprises in either direction.

A Margin Note Roadmap turns a body of findings into an ordered program of work. After an audit or a focused review, teams often know exactly what is wrong but disagree about what to fix first. The roadmap resolves that disagreement with evidence rather than opinion. Each entry in the roadmap cites the passage of the system it refers to, states the uncertainty it removes and estimates the disruption the change will cause.

Roadmaps are organized by the sequence in which work should proceed rather than by the size of each item. Some faults are cheap to fix but block the safe correction of larger ones, so they rise to the top. Others are expensive but isolated, and they can wait without cost. We mark dependencies explicitly, because the most common cause of stalled remediation is discovering midway that two fixes were entangled.

The roadmap is also a communication instrument. Engineering leads use it to argue for time and budget with the specific citations that justify each request. Executives use it to see where risk concentrates and which chapters of the system demand attention this quarter rather than next. When circumstances change, the roadmap is revised rather than discarded, because it is written to be maintained.

A Cross Reference Review examines the relationships between one system and its neighbors. Integration is where assumptions drift fastest, because two teams can each evolve in perfect good faith while the contract between them quietly becomes a fiction. We read both sides of every interface and verify that each claim either party makes about the other is still true.

The deliverable is a concordance of every reference across the boundary, with each one confirmed, broken or unresolved. Where a reference is broken we record the exact divergence, the direction of the drift and the moment it likely began. Where a reference is only informally maintained, we mark it as fragile, because a contract that lives in a document rather than in a test is a contract that will one day be violated by accident.

Cross Reference Reviews are especially valuable after a vendor change, a platform migration or a merger, when systems that were never designed to meet are suddenly expected to cooperate. They are equally valuable in steady state, as a periodic census of the seams, because the seams are where close reading pays off fastest and where its absence is most expensive.

A Reading Room Workshop teaches your engineers to read their own systems with the discipline we apply. We bring the passages, the questions and the pencils, and together we work through real parts of your system in a guided session. Participants learn to follow execution in order, to test every assumption they encounter and to record what they learn where future readers will find it.

Workshops are hands on by design. Rather than lecture about review practice, we place a genuine difficult passage in front of the group and read it together, pausing to notice the details that reward attention. By the end of a session a team has not only learned a method but applied it to their own code and surfaced findings that would have remained invisible under a faster process.

We offer workshop formats for small teams, for cross functional groups that include operations and product, and for leadership audiences who want to understand why slow reading is worth its cost. The method is the point: a team that can read closely does not need us in the room to find its own faults, and that independence is exactly what we intend to leave behind.

An Errata and Remediation Plan is the correction list that follows an audit, written as an erratum for each fault we have confirmed. Every entry names the passage it corrects, describes the risk the fault carries, specifies the correction and states how to verify that the correction held. Nothing is left vague. If a correction requires a decision that only you can make, the plan says so plainly and lays out the options with their consequences.

The plan is ordered so that each correction removes the most uncertainty for the least disruption. We separate the changes that are safe to make immediately from those that need staging, testing or a migration window, and we note which corrections can be verified by an existing test and which will need a new one. Where a fault cannot be corrected without accepting a risk, we say what that risk is rather than pretending it disappeared.

Errata and Remediation Plans can stand alone for a single subsystem, which makes them a practical first engagement for teams that want to see how we work before committing to a full reading. They pair naturally with a Margin Note Roadmap, which supplies the order, and with a Cross Reference Review, which confirms that a correction on one side of an interface is matched on the other.

A Quiet Hour Retainer is a standing relationship in which we keep reading your system a few hours at a time through the seasons. Systems drift. New features are added, old assumptions are inherited, and a body of knowledge that was once accurate slowly becomes a set of comfortable fictions. The retainer exists to catch that drift while it is still a footnote rather than a chapter.

Each retainer period includes a reading of whatever has changed since the last one, a short note describing what we found and what it implies, and a recommendation of anything that deserves a second look. The note is written in the same marginal style as our larger deliverables, so it slots into the record you already keep rather than creating a parallel one. Over time the notes accumulate into a history of the system as it was understood at each moment.

Retainers suit teams whose systems evolve continuously and who want a reader who already knows the manuscript. Because we begin with the context of earlier readings, a quiet hour spent later is worth far more than an hour spent cold. The rhythm is deliberately gentle: a few hours a month, a short note, and the assurance that someone is always reading.