Where does your repo drift most: local, CI, containers, or remote?

@colesimmons05 And it's never the missing package that takes the afternoon. It's the three hours of eliminating everything else before you finally land on it. The package itself installs in seconds once you know what it is.

Is it usually a missing package on your end or something harder to pin down like a version mismatch?

@ruby_diaz1 Nobody enjoys it, but almost everyone has a war story about it. There's something uniquely demoralizing about spending three hours on a problem that has nothing to do with the actual work you sat down to do.

What's the longest you've personally lost to an environment issue you'd rather forget?

@sophie_myers The classic. You refactor, rewrite, second-guess yourself for an hour, and then discover the code was fine the whole time. It's one of those debugging experiences that leaves a mark.

How far in were you the last time that happened before the environment turned out to be the actual culprit?

@ali_rehan1 The environment, almost always, and the gap is usually not close. Code failures at least give you something concrete to work with. Environment failures give you a symptom that could have ten different causes depending on who you ask and what machine you're on.

Has your team ever actually tried to measure how much time goes into environment fixes versus actual code issues?

@casper_voigt And that sentence alone is probably responsible for more lost engineering hours than most teams want to admit. The frustrating part is that nobody is wrong when they say it, the repo genuinely did work for them, in their environment, with their assumptions baked in. The problem is those assumptions were never written down anywhere the next person could find them.

What's usually the culprit when that happens on your team: environment variables, dependency versions, something else entirely?

@ellie_russell Small teams actually hit it earlier than you'd expect, just differently. With fewer people, there's less redundancy in who holds the setup knowledge, so when the one engineer who knows how a repo actually runs goes on leave or moves on, that knowledge doesn't always survive them. Bigger teams spread the pain across more repos and more handoffs, but the root cause is the same: setup truth lives in people's heads instead of the repo itself.

Have you felt it more at a certain team size?

@ethan_marshall New laptop is basically a forced audit of every assumption the team forgot it was making. The setup doc that nobody has touched in two years suddenly has to justify itself, and it usually can't.

Does your team have a ritual around new machine setup or is it still mostly "ask the person who's been here longest"?

@alistair_james1 Every team does, and that person is usually carrying more undocumented knowledge than anyone realizes until they're out sick or move on. The bus factor for environment setup is almost always one.

Is that person on your team aware of how much load they're actually holding?

@brielle_marie Never. The first error message is almost never the actual problem, it's just the first thing that broke visibly. What's underneath it is usually a chain of assumptions that nobody made explicit, and you only find the next one after you've fixed the current one.

What's the deepest you've had to dig before finding the real root cause?

@omri_ben_shoham1 It's both, but not magic. `ota detect` inspects supported repo-owned signals such as lockfiles, runtime manifests, Compose files, devcontainer configuration, and task definitions. It produces a candidate contract with provenance and confidence, while `ota init` can write a conservative starter from high-confidence findings.

We also maintain Ota Skills, which helps AI agents turn detected repo evidence into a reviewed, validated, and pressure-tested contract instead of guessing from scratch.

And yes, `ota.yaml` can drift too. Ota does not treat a structurally valid contract as automatically correct. `ota detect --merge --dry-run` compares current repo evidence against the existing contract, and `ota doctor` surfaces conflicts it can establish.

The honest limit is hidden state: if someone manually installed Postgres 14 years ago and the repo never declared an expected version, Ota cannot infer the missing intention. That remains an undeclared dependency until the team explicitly adds the expected version to the contract or another repo-owned source.

Which repo signals do you rely on most today when local and CI setup disagree?