# Diagnose with Ota, Then Run with Confidence > Source: > Published: 2026-06-06 11:04:19+00:00 Most repo blockers are discovered too late. A developer clones a repo, follows the README, runs the setup command, and only then finds out that the required runtime is missing. Or Docker is not running. Or the test database needs secrets they do not have. Or the command they ran was never the command CI uses. By then, the repo has already wasted their time. With AI agents, the cost is higher. An agent can inspect files, choose commands, edit code, and run tests. But if the repo does not surface blockers early, the agent may spend its effort on the wrong thing. It may treat a missing service as a code bug. It may retry a command that was never going to work. It may make changes before realizing the repo was not ready to execute safely. This is exactly the class of problem Ota is built to solve. Ota’s position is straightforward: a repo should not force humans, CI, or agents to discover basic execution blockers halfway through work. The repo should expose them up front, before execution begins, through one explicit contract for execution governance. That is why the better habit is simple: ``` Diagnose first. Run second. ``` A blocker is not the same as a bug. A bug says the software behaved incorrectly. A blocker says execution should not proceed yet. If Postgres is not running, the app may fail. But the failure does not mean the application logic is wrong. It means the environment is incomplete. If an API key is missing, a test may fail. But the fix is not necessarily in the codebase. It may require secrets, access, or user approval. If the repo requires Python 3.12 but the machine has Python 3.10, the build may fail before the project itself has even been tested. These are execution blockers. They should be surfaced before the repo asks humans, CI, or agents to do meaningful work. Late blockers are expensive because they look like ordinary failures. A missing service looks like a broken test. A missing runtime looks like a dependency issue. A missing environment variable looks like an application error. A risky command looks normal until it mutates state. For humans, this creates frustration. For CI, it creates noisy failures. For agents, it creates bad decision paths. An agent may see a stack trace and try to patch the code. But if the real blocker is missing Redis, the agent is now solving the wrong problem. It may edit files, rerun tests, and report uncertainty when the correct next step was simply: start the required service or stop and ask for credentials. Early diagnosis prevents that wrong turn. A repo does not need to diagnose everything before running code. It needs to diagnose the conditions that decide whether execution is safe and useful. At minimum, that includes: This is not about adding friction. It is about avoiding work that could never produce a trustworthy result. If a task needs Docker, check that early. If a test requires Postgres, say that early. If an agent is not allowed to mutate external state, stop before it reaches the risky command. There is a bad version of this idea: “Check so much that nothing ever executes.” That is not the goal. The goal is to make the next action obvious. If the repo is ready, run the declared task. If the repo is blocked, show the blocker. If the repo needs approval, stop and ask. If the repo requires secrets, do not invent them. If the task is outside the safe boundary, do not pretend it is safe. Good diagnosis should lead to movement. It should answer one practical question: ``` What is the next safe action? ``` For AI agents, blocker diagnosis is a guardrail. Before acting in a repo, an agent should know whether the repo exposes execution governance, which tasks exist, which tasks are safe, and where execution should stop. A safer Ota-backed agent loop looks like this: ``` 1. Run `ota doctor`. 2. Run `ota validate`. 3. Run `ota tasks --safe --use`. 4. Preview setup with `ota up --dry-run` when needed. 5. Run only declared safe tasks through `ota run `. 6. Stop when blockers require secrets, external services, or unsafe mutation. 7. Report the blocker and the next safe action. ``` This is not about making agents timid. It is about keeping agent execution bounded. A good agent should move quickly when the repo is ready and stop clearly when the repo is not. This is one of the clearest places where Ota’s framing matters. A blocker should not be discovered only after a human, CI job, or agent has already started running commands. The repo should be able to surface basic execution problems before execution begins. In an Ota-backed repo, that means the contract can describe what the repo needs, which tasks exist, which tasks are safe, and where execution should stop. Ota’s agent guidance follows the same rule: prefer the repo contract when it exists, execute only declared safe tasks, consume JSON output when automation needs it, and stop when blockers require secrets, credentials, external services, unsafe mutation, or paths outside the declared boundary. For example: `ota doctor` surfaces execution blockers before work starts.`ota validate` checks whether the contract itself is usable.`ota tasks --safe --use` shows what work an agent can actually run safely.`ota up --dry-run` previews setup before changing the environment.`ota run --json` runs declared work and returns stable status for automation.The point is not simply to put commands behind another CLI. The point is to avoid guessing whether execution should proceed, whether the task is safe, or whether the result means anything. That is the difference between reactive execution and governed execution. This is not only for agents. A repo that diagnoses blockers early is easier for humans too. New contributors know why setup is blocked. Maintainers get fewer vague “it does not work” reports. CI can fail earlier with clearer messages. Automation can stop before mutating state. Agents can report blockers instead of hallucinating fixes. The practical outcome is simple: less time spent debugging the wrong layer. Instead of asking: ``` Why did this command fail? ``` The repo helps answer: ``` Was this command safe and useful to run in the first place? ``` That is a better question. Running code is not always the first responsible step. Sometimes the responsible step is diagnosis. A repo should be able to say what it needs, what is missing, what is safe, and what should happen next before execution begins. That does not make development slower. It makes execution more intentional. The old habit is: ``` Run the command and see what breaks. ``` The better habit is: ``` Diagnose first. Run second. ``` That is how teams move from accidental execution to software execution governance. If you want that behavior to be explicit instead of tribal, start with `ota doctor` and give the repo one contract that can say what is blocked, what is safe, and what the next action should be before anyone starts guessing. Explore the Ota [getting started guide](https://ota.run/docs/getting-started) Check the Ota [examples](https://github.com/ota-run/examples) repo