Answers
Where does team memory fit in an AI-native software lifecycle?
The AI-native loop is well described as a sequence of artefacts: an intent written down, a plan derived from it, code produced against the plan, and review closing the circle. What the loop describes is how a unit of work travels. What it does not carry is what stays true between units — which rule is in force, who decided it, why an approach was abandoned, and what the people who never open the repository already settled. That standing layer is what Arroway holds: curated by people, ranked against the task, and delivered to the assistant with a receipt saying how much of it fit.
The loop moves work forward; it does not remember why
Every artefact in the loop belongs to one unit of work. An intent describes this feature, a plan sequences this change, a review judges this diff — and when the unit lands, the reasoning behind it lands with it, correct and finished and no longer consulted. The next unit starts from the same blank. Standing knowledge is the opposite shape: it belongs to no unit, it outlives all of them, and it is the part an assistant needs before it writes the first line.
Name a source of truth per artefact — including the ones with no file
The practice already asks teams to say where each artefact lives, and that discipline is what makes the loop legible. Follow it honestly and one column comes back empty: decisions and norms have no artefact. Not the pricing rule, not what may be sent to a client, not the reason a supplier was dropped, not the convention a team agreed in a meeting. Arroway is the answer to that row — the repository holds the code, and Arroway holds what the team decided.
Half the people who decide never open a repository
The loop is written for the people who commit, and the decisions that govern their work often are not made by them. Scoping knowledge to a codebase means a rule set by someone in sales, support or finance either gets copied into a file by a developer, or never reaches an assistant at all. Arroway scopes by project rather than by repository, so a decision written by someone who never touches git arrives in the read of someone who does.
What it looks like in practice
A team adopts the loop and it works: intents are written, plans are derived, reviews are tight. Six weeks in, an assistant proposes an approach the team abandoned in month one — with good reasoning, because nothing it can read says the approach was tried and rejected. The rejection was real and was discussed at length; it simply had no artefact, so it was never in front of the model. The loop was followed correctly and still produced the same wrong answer twice.
Questions people ask about this
- Is this a replacement for the intent and plan files?
- No. Those artefacts describe a unit of work and are correct where they are. Arroway holds the layer underneath them — what is in force across units — and the two meet at the moment an intent is written: an intent drafted against the team's standing decisions is a different document from one drafted against a blank page.
- Why not keep decisions in the repository too, next to the artefacts?
- Some teams do, and it works until two things happen. A decision is overturned and the old line keeps reading as current, because a plain file has no way to say it was superseded. And someone outside the repository makes the call, at which point the knowledge either gets copied by hand or never arrives. Arroway carries an explicit kill condition, a chain pointing from a superseded memory to what replaced it, and a scope that is not a codebase.
- Where does the assistant get this during the loop?
- At the start of the work, through the connector, before it plans anything. The read is ranked against the task the assistant declares and comes back stating the budget it used and what did not fit, so "the assistant knows the team's rules" is something you can check rather than assume. Whatever an assistant learns along the way it can propose back, and a person sanctions it in review — only what a human sanctioned governs the next read.
Where this is verifiable
Product documentation on this site (How it works, Install) and the sanctioned product spec in the repository. The description of the AI-native loop refers to the publicly published practice of naming an artefact and its source of truth per stage; this page makes no claim about any specific tool's behaviour, and no claim about the built-in memory of any AI product.
https://www.arroway.app/en/answers/team-memory-in-the-ai-native-sdlc