Skip to content

AI-native development team

Several people and more assistants than people, working the same repository at the same time.

AI-native development team

Who this is

A team that has already reorganised around assistants rather than merely adopted them. Two to ten people, and at any moment more sessions than people: coding agents in worktrees, review agents on branches, overnight runs nobody watches.

How they work

Work is fanned out. A person states an outcome, several workers attempt parts of it, and somebody integrates. The bottleneck moved: it is no longer typing, it is knowing what the other workers already did, already decided, and already broke.

What goes wrong

Duplicated work that looks like parallelism. One worker undoing another's change because neither could see the other's scope. A repository where three sessions each believe they own the same file. Isolation — a worktree each — defers the collision without preventing the duplication, because what prevents duplication is a declared, visible scope.

25 moments

Every moment that names this one. Derived from the moments; this page keeps no list.

  1. re-explained the same context to a brand-new sessionRepository knowledge that only ever existed in a conversation has to be re-transmitted by hand to every worker that follows. cost: mediumconstant Why, and what to do →
  2. found two agents fixing the same bug in two branchesTwo workers spend a day each on one defect because ownership was implicit and neither could see the other. cost: highcommon Why, and what to do →
  3. accepted "done" because the model said so, and paid for it the next morningA fluent completion claim is accepted as evidence because nothing wrote down, beforehand, what would have to be true. cost: highcommon Why, and what to do →
  4. opened CLAUDE.md and AGENTS.md and found two different rulebooks for one repositoryEach provider reads its own hand-edited file, nothing relates them, and which contract applies depends on which tool is open. cost: highcommon Why, and what to do →
  5. watched a session undo last week's decision, for the reason it was madeA decision whose reason lived in a conversation cannot be reviewed, only re-argued — by a worker with less information than the first one had. cost: highcommon Why, and what to do →
  6. found a task "in progress" that nobody had touched for three weeksA status that was authored rather than computed is true at the moment of writing and decays silently from then on. cost: mediumcommon Why, and what to do →
  7. asked what the workers did last night and had only transcripts to grepA conversation log records what was said, not what happened, so the operational question has to be answered by a person reading prose. cost: highcommon Why, and what to do →
  8. found the rule for that directory in a README no session ever loadedA 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. cost: highcommon Why, and what to do →
  9. spent an hour discovering something the repository already knew, twiceA worker learns something expensive about the codebase, uses it once, and it dies with the session because nothing turned it into a durable record. cost: mediumcommon Why, and what to do →
  10. watched the always-loaded instruction file grow past a thousand linesEverything important gets appended to the always-loaded file, so every session pays for every rule and reads none of them carefully. cost: mediumcommon Why, and what to do →
  11. watched one worker revert another worker's change, on purposeA worker sees an unexplained change in its path, judges it wrong, and removes it — correctly, on the evidence it had. cost: highoccasional Why, and what to do →
  12. found five worktrees and could not say which of them still matteredIsolation is cheap to create and expensive to reason about: nothing records what a worktree was for or whether its work landed. cost: mediumcommon Why, and what to do →
  13. found finished work on a branch that nobody ever mergedWorkers produce far more than integration absorbs, and nothing distinguishes work that is done from work that is done and landed. cost: highcommon Why, and what to do →
  14. had two sessions writing into one checkout without either knowingTwo workers in one working tree see each other only as unexplained file changes, and each treats the other as noise. cost: highoccasional Why, and what to do →
  15. changed a policy in one place and found the old one still in force in three othersA decision is updated at its source and the generated copies keep serving the previous version, with nothing reporting the difference. cost: highcommon Why, and what to do →
  16. went looking for why we chose this and found a chat logA decision that was reached in a session is stored where only that session can read it, so it is neither reviewable nor discoverable. cost: highconstant Why, and what to do →
  17. found code that contradicted a decision the repository had written downThe decision was recorded and the implementation went the other way, because nothing relates a decision to the paths it governs. cost: highoccasional Why, and what to do →
  18. closed an issue whose acceptance criteria nothing had actually checkedCompletion is recorded as a state change in a tracker rather than as evidence in the repository, so the two drift immediately. cost: highcommon Why, and what to do →
  19. shipped an interface change whose contract document still described the old oneA contract maintained by hand beside the code it describes goes stale on the first change that forgets it. cost: highcommon Why, and what to do →
  20. pasted a command from the documentation and watched it failExamples are written once, in prose, and nothing ever executes them again. cost: mediumcommon Why, and what to do →
  21. had a green pipeline over generated files that no longer matched their sourcesTests exercise the code and say nothing about the committed outputs derived from it, so the build is green and the artifacts are wrong. cost: mediumcommon Why, and what to do →
  22. lost a failure a worker had already reproduced, because the session endedA 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. cost: mediumcommon Why, and what to do →
  23. found the same thing explained three times, slightly differentlyEvery hand-maintained copy of a fact drifts on its own schedule, and a reader cannot tell which copy is the current one. cost: mediumconstant Why, and what to do →
  24. spent the first hour in an unfamiliar repository working out what was normal hereWhat is conventional in a codebase is knowledge held by its regulars, so every arrival — human or machine — pays for it again. cost: mediumconstant Why, and what to do →
  25. watched a worker spend a day on an approach that had already been ruled outNegative results are the majority of experimental output and the part nobody records, so the search space is re-explored. cost: mediumcommon Why, and what to do →