why · 38 operational failure modes
38 operational failure modes AI-heavy teams meet, who recognises each, what actually causes it, and what Majordomus does and does not do about it.
None of these are model problems. They are operations problems, and operations is what Majordomus does.
Every audience below names the moments it recognises first. Pick yours; the six that weigh most for it are shown, and the audience page holds them all.
One person, several assistants, and no one else to ask what was decided yesterday.
Several people and more assistants than people, working the same repository at the same time.
Accountable for what shipped, without having watched any of it being written.
Owns the rules, the tooling and the execution environment that everybody else works inside.
Reviews contributions from people and machines they have never met, against conventions only they know.
Many clients, many repositories, and context that must transfer between people in hours rather than weeks.
Answerable to auditors, not only to users: what was done, by what, under which policy, with what evidence.
Many more experiments than results, and the expensive part is remembering which ones were already tried.
Every moment falls under one or more areas. Each card names the area, what it covers, and the three moments that weigh most in it; the area page holds the rest.
What a worker knows when it starts, and what survives when it stops.
Who holds what, who is doing what right now, and what happens where two workers meet.
Which rules apply here, whether anything loads them, and whether they still agree with each other.
What was settled, why, and whether the next worker can find out before reopening it.
What is in flight, what is finished, and whether the repository agrees with the tracker.
Whether "done" is a claim or a fact, and what would prove the difference.
What actually happened while nobody was watching, in a form that is not a transcript.
What was spent, on which task, at which capability, and whether the choice was ever recorded.
Whether what is written still describes what exists, and how many copies of it there are.
Which of these happened to you this week?
Every line below is a signal one of the moments declares. Tick what you recognise; the profile that appears is counted from the metadata of the moments you picked, not scored by anything.
Every filter below is a value some moment declares, counted over the catalogue. Nothing here is a list somebody keeps.
re-explained the same context to a brand-new session
Repository knowledge that only ever existed in a conversation has to be re-transmitted by hand to every worker that follows.
found two agents fixing the same bug in two branches
Two workers spend a day each on one defect because ownership was implicit and neither could see the other.
watched the strongest model, at maximum effort, rename a variable
Capability, reasoning depth, context size and verbosity collapse into one habit — everything on — because nothing ever named them separately.
accepted "done" because the model said so, and paid for it the next morning
A fluent completion claim is accepted as evidence because nothing wrote down, beforehand, what would have to be true.
opened CLAUDE.md and AGENTS.md and found two different rulebooks for one repository
Each provider reads its own hand-edited file, nothing relates them, and which contract applies depends on which tool is open.
watched a session undo last week's decision, for the reason it was made
A decision whose reason lived in a conversation cannot be reviewed, only re-argued — by a worker with less information than the first one had.
found a task "in progress" that nobody had touched for three weeks
A status that was authored rather than computed is true at the moment of writing and decays silently from then on.
asked what the workers did last night and had only transcripts to grep
A conversation log records what was said, not what happened, so the operational question has to be answered by a person reading prose.
found the rule for that directory in a README no session ever loaded
A local rule is either in the always-loaded file, where every session pays for it, or beside the code, where nothing relates it to the path being edited.
read three roadmaps for one project and believed none of them
A plan kept in prose is a snapshot, and every copy of it drifts on its own schedule; stored status is an assertion that stays true after the world moves.
spent an hour discovering something the repository already knew, twice
A worker learns something expensive about the codebase, uses it once, and it dies with the session because nothing turned it into a durable record.
watched the always-loaded instruction file grow past a thousand lines
Everything important gets appended to the always-loaded file, so every session pays for every rule and reads none of them carefully.
watched one worker revert another worker's change, on purpose
A worker sees an unexplained change in its path, judges it wrong, and removes it — correctly, on the evidence it had.
found five worktrees and could not say which of them still mattered
Isolation is cheap to create and expensive to reason about: nothing records what a worktree was for or whether its work landed.
found finished work on a branch that nobody ever merged
Workers produce far more than integration absorbs, and nothing distinguishes work that is done from work that is done and landed.
had two sessions writing into one checkout without either knowing
Two workers in one working tree see each other only as unexplained file changes, and each treats the other as noise.
changed a policy in one place and found the old one still in force in three others
A decision is updated at its source and the generated copies keep serving the previous version, with nothing reporting the difference.
found a rule everyone believed was enforced and nothing ever invoked
Every artefact of enforcement exists — the rule, the script, the test — and no path connects them, so the control is fiction.
went looking for why we chose this and found a chat log
A decision that was reached in a session is stored where only that session can read it, so it is neither reviewable nor discoverable.
found code that contradicted a decision the repository had written down
The decision was recorded and the implementation went the other way, because nothing relates a decision to the paths it governs.
found a substantial change that no issue, ticket or plan ever asked for
Work arrives with no bounded contract behind it, so its scope, its acceptance criteria and its ownership are all decided after the fact.
closed an issue whose acceptance criteria nothing had actually checked
Completion is recorded as a state change in a tracker rather than as evidence in the repository, so the two drift immediately.
was asked how far the milestone had got and had to go and ask four people
Progress is an aggregate that exists only in people, because the parts it aggregates were never recorded in a form anything can add up.
read a promise in the README that no test stood behind
A sentence describing what the software does is written once and never connected to anything that would fail if it stopped being true.
shipped an interface change whose contract document still described the old one
A contract maintained by hand beside the code it describes goes stale on the first change that forgets it.
pasted a command from the documentation and watched it fail
Examples are written once, in prose, and nothing ever executes them again.
had a green pipeline over generated files that no longer matched their sources
Tests exercise the code and say nothing about the committed outputs derived from it, so the build is green and the artifacts are wrong.
let a fast, cheap session make a decision the whole codebase now lives with
Capability is dialled down for cost and nothing distinguishes the tasks where that is prudent from the ones where it is expensive.
could not say why one provider was used for that work and another for this
Provider and model selection is made implicitly, per session, and recorded nowhere, so it cannot be reviewed or repeated.
looked at the bill and could not say which of it produced anything
Consumption is measured per account and outcomes are recorded per person, so the two can never be joined.
lost a failure a worker had already reproduced, because the session ended
A failure observed inside a session is described in that session and nowhere else, so the next one starts from the report rather than the evidence.
found the same thing explained three times, slightly differently
Every hand-maintained copy of a fact drifts on its own schedule, and a reader cannot tell which copy is the current one.
published a page that promised more than any test could support
Public material is written by a different act from the code, so it drifts ahead of the behaviour and nothing brings it back.
spent the first hour in an unfamiliar repository working out what was normal here
What is conventional in a codebase is knowledge held by its regulars, so every arrival — human or machine — pays for it again.
reviewed a well-written contribution that broke a convention it had no way to discover
Assistants let anybody produce plausible contributions at volume; the conventions that make one correct are still only in the maintainers.
watched a worker spend a day on an approach that had already been ruled out
Negative results are the majority of experimental output and the part nobody records, so the search space is re-explored.
could not reproduce a result because nothing recorded the state it came from
The result is recorded and the conditions that produced it are not, so it is an anecdote rather than a measurement.
was asked who made a change and under what policy, and had only a commit
Attribution stops at the commit, so what authorised a change, what verified it and what governed it are unrecoverable.
Nothing matches that. .
Every moment, who recognises it, the area it falls under, and the commands, capabilities, claims, rules and use cases that answer it — one graph, derived from the moments themselves. Nothing on this site is a second list.