Testing the patterns on real material

Where this came from

The previous piece on context debt ended on a limitation: its five patterns came from one fictional company in a single demonstration, and the next step was to test them against real material. This is that test.

There's no client material to publish here, so the real material is the next best thing available and fully verifiable: this site's own Flask codebase. Every claim below could be checked by anyone with the repository as it stood when this was written, in August 2026, which is closer to "we tested this" than most audits get to be in public.

The subject

The site's app.py needs to know, in several different places, which routes exist: which pages belong in the sitemap, which demo slugs are valid under /work/, which tool slugs are valid under /tools/, and which case studies have a custom diagram embedded in them. None of that information lives in one place. It's copied into four separate, hand-maintained lists, each written independently of the actual route table Flask already builds from the @app.route decorators themselves.

The finding

This is the same pattern as No Record, from How context debt shows up, just showing up in a codebase instead of an HR handbook. A real, current state exists (which routes the app actually serves) and is accurate at any given moment. But the systems that need a derived version of that state, the sitemap generator, the 404 handler, the diagram-loading logic, don't read from the source of truth. They read from a hand-copied version of it that has to be kept in sync by whoever adds the next route remembering to update every list that needs to know about it.

When this was written, every list was accurate. That's what context debt usually looks like before it turns into a problem: correct for now, with nothing to raise an alert when someone forgets to update it. Neither the sitemap nor the 404 page has any way to notice when it stops matching the real site. The uncurated reply in the support-context demo was technically accurate on first inspection too, and still left out something a downstream system needed. Same pattern, different place.

The site has already lived this rather than just described it. Building the Research section meant updating three hand-kept lists at once (static_pages, TOP_LEVEL_SECTIONS and the 404 slug logic), because none of them update themselves.

What this doesn't mean

This isn't an argument that hand-maintained lists are always wrong. A list that's read often and touched rarely, by one person, who wrote the pattern this article is describing, is low-risk context debt. The Context Debt Map's own worked examples (a 2019 policy nobody updated, an approval that lived only in a Slack DM) are what the same pattern looks like at a company's scale, across more people, over more years, with no one person holding the whole picture. The mechanism is identical. The blast radius isn't.

The actual fix, if it's worth making

Flask already exposes the real route table as app.url_map. Deriving static_pages, WORK_DEMO_SLUGS, TOOL_SLUGS and DIAGRAM_EMBEDS from that (or from the content directories directly, the way load_all_articles and load_all_research_articles already do) would remove the "remember to update this too" step entirely. That's a real, scoped code change, not a rewrite, and it's the natural next thing to apply once this finding exists: an audit that ends in a fix, not just a name for the problem.

(What happened next: The debt came due.)