Diff Guard

1. Re-entry: branch, mode, narrow task

Until now, people had almost led him by the hand: Oliver taught him how to read other people's code, Alex showed him the tools. Now Tommy is putting together the fix from scratch and on his own — with Sam, from a clean branch to the merged result. He has everything he needs: scope, three classes of changes, and a mode set to risk. The task is simple: make exactly one door and do not let the whole apartment get repainted.

In the morning, he would have rushed straight into the file. Now he stops.

— Okay, slow down, he says under his breath. — Like Oliver taught: slowly and in order.

First things first — the branch. He has not touched other people's code on main in a long time; that is already a reflex.

— First, lay down some padding, he mutters and writes to Sam in plain words:

Create a branch for the partner-zone fix and switch to it.

Sam creates fix/partner-link — main stays untouched, and there is somewhere to roll back to if it goes sideways. For good measure, Tommy checks again:

what branch am I on now?

— fix/partner-link, not main, — Sam reports.

— Good. — Tommy exhales. — Now the trust wheel. This is someone else's code; I don't trust it blindly.

He hits Shift+Tab until the mode switches to manual:

Shift+Tab → manual      # on someone else's code, NOT acceptEdits: I want to see EVERY change

In the session status: ⏸ manual mode on, not acceptEdits. Now no change will go into the file until Tommy has looked at it himself.

— And only now — the actual task, he says. — Not like this morning. With boundaries.

He writes it narrowly, with a forbidden block:

In the partner zone, fix the link in the sponsor block to point to the new address. Do not touch anything else.

Sends it.

2. Breaking down the diff by buckets

Sam makes the needed change — and, as Tommy already knows, drags a tail behind it. He says it is ready to apply and waits: manual mode did its job, nothing has gone into the file yet. Tommy opens /diff — and sees everything at once: the actual target change, the contractor's foreign formatting, a couple of small beautify touches, and movement in a neighboring area that the task never asked to enter.

/diff       # look at the whole run: how much is from the task, how much is "while we're at it"

Before, Tommy would have skimmed past this and nodded. Now he leans toward the screen and goes through the diff slowly, suspiciously, without slipping. For the first time in his life, he is not a passenger on the diff but the guard — and out loud he sorts every piece into buckets.

— So. Here is the target — the door they asked to paint. I take that. — His finger moves lower. — And what is this? Smoothed out the formatting, shuffled the indents... I did not ask for that. Extra. — Lower still, and he frowns. — Here you even wandered into a neighboring area, and I do not even know what is holding up there. Dangerous, hands off. — And he freezes on the last one: an uninvited animation, logos floating up softly, really expensive-looking work. — Oh, that is beautiful... old me would have put that straight into a portfolio. — His finger hangs there for a second. — But it was not ordered. And not in someone else's code. Unexpected — pass.

— Leave only the target change? — Sam asks.

— Nope. — Tommy shakes his head. — One needed line got drowned in the tail; the whole run is crooked. diff is there so I can understand, not so I can pick it apart piece by piece. I am rejecting it wholesale.

He rejects the changes — nothing goes into the file. And he sends Sam back not just with "do it again," but with a tighter boundary so there is no tail at all in principle:

Only the link in the sponsor block. Do not touch formatting, neighboring areas, or the animation at all.

Sam comes back — and this time the diff is short: one line. That very door. Tommy goes over it once more as the guard — clean, no tail — and only then accepts it.

— Imagine that, Sam, — he says, and catches himself saying it, — for the first time in my life, I am proud not of what I piled on. But of what I did not do. Back then, the thrill was in "wow, look how much I crammed in." And now it is in not a single extra bit slipping past me. Quieter, but sweeter.

3. One run — straight into the bin

In one of the runs, Sam speeds up so much that the diff again takes up half the screen. Fishing it out one by one is both tedious and dangerous: blink and you miss a dangerous piece.

— Bad take, — Tommy says without the old panic. Half a course ago he would have frozen here — "that is it, I broke it again." Now he just shrugs and hits /rewind. The whole run — straight into the bin.

/rewind     # roll the sprawling run back as a whole, return to the state before the fix

— Funny, he says to Sam, looking at the clean window. — Back at the start of the course, I almost worshiped that button. It was the only thing saving me.

— And now? — Sam chimes in as if playing along.

— And now it is just the top safety net. Under it is the branch, under the branch something else. Before, all the protection hung on one /rewind, and now I have several of them. Let's go in again, a little more carefully.

4. Locking the rules into settings.json

After a couple of runs like that, Tommy realizes that managing everything by hand every time is a pain. It is always the same: the partner zone is under scrutiny, the frozen chunk is locked down tight. He asks Sam to put that into a rule in settings.json, so he does not have to decide again at every step:

{
  "permissions": {
    "ask":  ["Edit(src/partner/**)"],
    "deny": ["Edit(legacy/**)"]
  }
}

It reads plainly: changes in the src/partner/ folder — ask before every one; in legacy/, the old frozen chunk of the portal, — strictly forbidden, the agent will not even go there.

— Come on, let's check that this is not just for show, — Tommy deliberately nudges Sam into legacy/. The rule triggers, the door is locked. — Oh, that hits the right address exactly. Not "all or nothing," but exactly where it needs to be.

5. Came in, did it, left

The day is winding down, Tommy wraps up the work properly — records the clean fix in git and even prepares it for merging. Sam will do everything himself - he just needs to ask in plain words:

Commit the partner-link fix with a meaningful message and prepare it for merging into main.

Sam makes a commit with a clear message and prepares the branch for merging. Tommy opens the diff one last time to check. One line. That very door. There is nothing else in the branch.

He scrolls down — to where the cosmetics had spread out in the morning. The other person's layout sits exactly as it did: the same strange indents, foreign names, its own crooked logic. That block he never understood is intact precisely because Tommy did not touch it.

— Came in, did the job, left, he says out loud to the empty room. — And did not break anything.

He runs his finger across the screen, over the other people's lines he never touched.

— Funny, — he says into the void. — A month ago I would not have even counted this as work. Where is the scale, where is the wow factor? One line, who is going to notice it. — He shakes his head. — And that is exactly what makes it class. The fact that it is unnoticed. That nobody will even guess how much I did not break here.

6. Came in and left no trace

Oliver, who has been watching this care with a side glance all day, comes by at the end — and does not grumble. He looks at the narrow clean diff, at the untouched neighboring area, and says simply:

— That is how it should be with someone else's code. Came in, touched it carefully, left. Left no trace.

— Uncle Oliver, you spent a month nagging me about toys, Tommy looks up from the screen. — And now you are praising me for one line. People used to praise me when I did a lot and it was flashy. And you — when it is little and unnoticed.

— That is the harder part, — Oliver shrugs. — Anyone can pile things on. But to go into someone else's work and not break anything — that takes skill.

Tommy says nothing. And that stingy Oliver "harder" weighs more now than the whole office's praise for half a screen of animations.