AI Powered

The request arrived as one line: let many organizations share one blog platform without ever seeing each other's data. It reads like a feature. It is closer to a property — something that has to stay true of every query, every link and every email the platform will ever produce.

Hand that sentence straight to an agent and you get a confident diff that answers the half of the question it understood. So the first hour was not code. It was pulling the sentence apart until every branch ended in something a person could decide, and writing those decisions down where the agent would find them.

An agent starts every session knowing nothing about your codebase except what you put in front of it. That makes context the actual interface — and the obvious move, one enormous instructions file, is the wrong one. Everything in it competes for the same attention, and the rule that matters today is buried under the ones that mattered last month.

What worked was an index at the centre and a scoped rule file for each area of the system. The index is short and points outward. A rule loads only when the agent touches the area it governs, so the data-layer rule is in the room exactly when somebody is about to write a query — and nowhere else.

The cheapest place to be wrong is a plan. Before any change of size, the agent writes one — what it will touch, in what order, and what would tell us it worked — and I read it the way I would read a colleague's design note. Most corrections happen here, in a sentence, instead of later in a diff.

Skip it and the agent plunges: it picks the first plausible path and builds on it, and you discover the wrong assumption three files in, when undoing it costs more than the feature did.

Once the plan holds, the work fans out. Schema, data layer, request handling, host resolution and DNS form a graph, and anything without an unmet dependency can run at the same time. More agents is not automatically faster: two of them editing the same file is a merge conflict with extra steps, so the graph decides how wide to go.

Then a reviewer that took no part in writing the code reads all of it. Independence is the whole point — the agents that wrote a query are the worst placed to notice it quietly lost its tenant filter. A human gate sits after that, and nothing merges past it.

“Done” from an agent is a claim, not a result. The loop only closes when something other than the agent checks the work — a type check, a build, and for this feature above all, the isolation test that tries to read one workspace from inside another.

The useful exercise is to switch the defences off one at a time and watch what happens. Each layer covers for the other, and the test is what turns a quiet failure into a loud one before it ships.