Answers
Each change my agent wrote looked fine. Why is the code the way it is, and who decided?
Because a later session read the earlier code as the team's way of doing things, and nobody decided that. An agent's change can be reasonable on its own; the next session sees it in the repository and treats its choices as the pattern, and months later nobody can say whether a choice was deliberate or just the first thing that was written. What helps is keeping the choice that mattered outside the code, as a decision: what was chosen, why, who approved it, and what would end it. In Arroway an assistant that made a call records it as a proposal, a person on the project approves, edits or discards it, and the approved decision is what every agent is told is in force when it opens the project, so it follows the decision instead of inferring a pattern from a diff. Arroway does not review code and does not stop a session from copying what it sees; it keeps the reason where the agents read it. The install page is the first step.
Last updated October 30, 2026
How a choice becomes a precedent without anyone choosing it
A coding agent decides many small things in a change: which library, where a check lives, how an error is handled. None of them needs a discussion, and each can be defensible alone. The trouble starts when they leave no record except the code itself. The next session reads the repository to learn how things are done here, and what it finds is that earlier agent's choices, which it reads as the house style. Nothing marks the difference between a deliberate rule and an accident of one afternoon. The reason is lost first, and then the ability to tell which parts could change.
What to keep outside the diff
Only the choices that would surprise someone later, and four things for each: what was decided, the reason, who approved it, and the condition that ends it, such as a migration that finishes or a vendor that changes its terms. In Arroway the assistant that made the call records it as a proposal while it works, and the work does not wait. A person on the project then approves it, edits it or discards it. An approved decision is served to every agent that opens the project with its approver and its end condition, and a later decision that replaces it says which one it replaces, so the history reads as a chain and not as a pile of contradictions. The agent still sees the code, and may still copy it. What changes is that the reason is in front of it before it does.
When to use Arroway
Use Arroway when agents write a meaningful share of your code and a new session has to extend what an earlier one built, especially if people join the project after the first changes shipped. Record the choice at the moment it is made, not months later when someone asks. Arroway does not review the code, does not detect accidental patterns by itself, and cannot tell a good choice from a bad one; it keeps the choices a person approved, with their reason and end condition, where every agent reads them. The first step is the install page.
What it looks like in practice
Rui's team lets an agent build a reporting feature. To keep it quick, the agent catches a database error and returns an empty list, and the change is merged because it works. Two weeks later another session adds a second report and copies the same handling, because the first one is how errors are handled in this repository. By the fifth report, a failed query shows up as an empty chart, and nobody remembers choosing that. In Arroway the first session records the call as a proposal with its reason: empty list on error, for the prototype only. Rui approves it with the end condition that it stops when the reports go to customers. A later session reads it as a temporary decision with an owner, not as the style of the codebase. Nothing here was measured on a real project; the team and the feature are illustrative.
Questions people ask about this
- Does Arroway tell me which of my agent's choices became accidental patterns?
- No. It does not read the code or detect patterns. It keeps the decisions a person approved, with the reason and the condition that ends each one, so an agent can tell a deliberate choice from something it merely saw in the repository.
- Do I have to record every choice an agent makes?
- No, and trying to would bury the ones that matter. Record the choices that would surprise someone later: the ones that shape how other code gets written, or that you would not want copied by default.
- How do I try Arroway?
- Install it in the tool you already use — the install page has one route for Claude, ChatGPT, Codex, Cursor or any MCP tool — and sign in when the tool asks. From then on, sessions open by reading the project and close by recording what was decided.
Where this is verifiable
Product documentation on this site (How it works, Install), the answers on decisions that outlive a session and on out-of-date memory being read as current, and the proposal, sanction, supersession and expiry-condition rules in the sanctioned product spec. Everything described here about Arroway is behaviour the tools apply today, not roadmap. The team, the agent and the feature in the example are illustrative.
https://www.arroway.app/en/answers/why-the-code-is-the-way-it-is-when-agents-wrote-it