Full cycle from spec to delivery

1. Branch and targeted handoff — one continuous gesture

The plan is agreed on — Tommy keeps going, and Alex, watching him, suddenly notices:

— Listen, have you noticed how you work right now? Not once did you stop to think, “what now?” You wrote the spec, cleaned up the window, pulled up the plan, fixed it — and kept going, as if on one breath.

Tommy listens to himself — and it is true.

— Oh. And that is exactly it. Back then I practiced every step separately, like scales. The branch — remember. The check — remember. And now it flows by itself, one from another. One gesture.

— That is what getting the hang of it is called, — Alex snorts. — Well, show me your gesture.

First of all, he does not rush to edit main. Any portal change goes through a branch — his hand does it automatically, a reflex ever since he tore the project apart and learned to keep experiments to the side. He writes to the agent in plain words:

Before the fix, create the fix-reward-flow branch and work in it; do not touch main.

● git checkout -b fix-reward-flow      # branch created — work kept away from main

Main is intact, experiments are separate. Now — the files. And here he does not repeat the old stupidity, “read the whole portal, figure it out” — that would clog the window he just cleaned again. He passes in exactly the two files related to the reward flow, the very ones Alex showed him:

Make the reward fix based on @src/reward-flow.js and @src/rules.md. Do not read the rest of the portal.

The agent keeps only what is needed in the window — the reward logic and the rules behind it — and fixes it with focus, without dragging the entire repository into the window. Cheaper and more precise. He created the branch and passed the files in with precision, without any “I should probably” — everything fell into one gesture together with the plan, all by itself.

2. Diff, test, and the green trap

The agent delivers the fix. And Tommy does not take it on faith — first he looks at the change with his own eyes:

/diff       # line by line: what changed in reward-flow, did it touch anything extra

The changes are only in the reward logic. /legacy and the neighboring zones were left untouched — exactly as he cut them off in the plan. If there had been an extra tail, he would have rejected it and kept only the target fix. But there is no tail, everything is clean. Only now — the check.

And he does what would have seemed like pointless fuss a year ago. First he runs the test on the fixed version:

Run the reward test.

● npm test        # reward test is green on the fix

Green. But Tommy already knows: green by itself proves nothing — maybe the test is just blind and turns green all the time. So he catches the green trap — he checks the test itself. He rolls back the fix and runs the test on the broken version: it must go red, otherwise it is useless.

● git stash       # temporarily remove the fix — bring back the broken reward flow
● npm test        # on the broken version, the test MUST fail

A brief moment — and the test honestly turns red. The bug is there, the test sees it, the reward flow is lying. Not “it seems to me,” but here it is, black on red. Tommy smirks — you end up happy to see red. He restores the fix:

● git stash pop   # bring the fix back

Red on the broken version, green on the repaired one. There was a bug — the bug is gone, and that can be seen not on his face, but in the repeatable result that anyone can run and see the same thing. Honest green, not a trap. That is the whole difference between him now and himself from the vibe era: back then he believed it was done because it looked done. Now he proves it.

3. Evidence in EVIDENCE_LOG and the delivery report

While the fact is still fresh, Tommy puts it into the log — not as a separate paper scene, but with one line to the agent right from the work:

Record in EVIDENCE_LOG: the symptom, the test failing on the broken version, the fix, and the honest green.

A short trace of one cycle goes into EVIDENCE_LOG: before/after on the reward flow, confirmed by a real run. Not for paperwork — as proof that it was truly fixed, something that can later be presented without a word. The core fix is accepted in the branch.

And now a grown-up package is assembled into the submission/ folder: the spec, this very evidence log, the delivery report, and that inventory of the arsenal. The last document, the delivery report, Alex names on the fly — DELIVERY_REPORT, a short final note on the closed cycle. And, as all day long, he barely explains it: Tommy already senses the shape.

Tommy asks only one thing — how the delivery report differs from the evidence log, which is already sitting nearby.

— The log collects facts as you go, — Alex answers. — And the delivery report brings them together into one calm point for the person accepting it. The log is a diary. The report is the final summary.

That is enough for Tommy. He derives the rest from what he just went through himself, and boils the report down to four lines:

# DELIVERY_REPORT — reward flow fix
WHAT I AM DELIVERING: reward point calculation fixed in reward-flow (level multiplier was lying)
HOW IT IS PROVEN: test red on the bug → green on the fix; screenshot of the correct leaderboard
OUT OF SCOPE:       live data in the radar — as a separate short pass (outside this fix)
WHERE TO LOOK:      TASK_SPEC + EVIDENCE_LOG in submission/

The report settles into the package by itself, because Tommy already had everything for it in his hands — all that was left was to summarize. And the package feels not like a paper boss that needs to be beaten, but like neatly collected traces of an already completed calm cycle. Before, such grown-up documents were born around him or with Alex's help. Now they are his. Truly.

4. Speed returns with discipline

The core cycle is closed, the result is proven, the window is cleaned. And now — what he has been waiting for all morning.

— Well, now we can do something for the soul too, Tommy says out loud and stretches.

He opens a fresh session and, for a second, pauses — how did he do this back then, on the radar? Live data instead of a placeholder... His hand remembers before his head does.

— Ah, right. The same tremors I pulled into the radar. Back then, on the radar, I hooked them up through an MCP bridge — a special cable to the service. But here it is simpler: the page fetches them directly, with a regular fetch by address.

And he calls the agent — not with a dry command, but with that very excitement he has missed:

Fetch the latest earthquakes from USGS directly via fetch and bring the block radar on the portal to life with live data.

He knows the source by heart — the public USGS feed, the same one as on the radar, no key needed:

https://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/all_hour.geojson

The agent goes to the external API with a direct fetch, pulls real GeoJSON, and embeds the block. And the portal comes alive — real fresh quakes light up on the map, magnitude and location are pulled from the real world, not from a placeholder. That same feeling: not “I drew it nicely,” but “I reached into the live world and brought it onto the screen.” Tommy catches the familiar high — the one he really missed over these days of serious discipline.

And then Alex catches him:

— Notice what you just did? More precisely, what you did not do. You did not create a branch, did not run diff. On the fix you ran everything full blast, and here — no.

Tommy freezes, rewinds — and it is true.

— Listen, my hand did not even twitch. And not because I forgot.

— Because the weight is different, — Alex nods. — You already worked out the discipline on the core fix; that was where it was needed. And this is a bonus on top, on a clean window, so the demand is lower — you can feel where to tighten the bolts and where to let go. The chain is familiar, still from the radar: source, request, response, screen. Only the cable is different — there it was a bridge, here it is a direct fetch — but the essence is the same.

— Only now the magic is not instead of the process, Tommy finishes. — It comes after it.

He watches the live quakes blink on the portal. A month ago, a thing like this would have blown everything to pieces — he would have gobbled up the magic, skipped the checks, and that would have been that. And now it just shines on top, on clean work, and breaks nothing. The miracle did not disappear. It just is no longer in charge.

5. The work is accepted without questions

Tommy sends the result to Tony. And waits. By old habit, tension rises inside him: now comes the review — “did you check it? are you sure this will not break here? show me, I do not believe it.” It was always like that. He even had a response ready.

The answer is silence. A minute. Two. No review. No control questions. Tony simply accepted the work — and that is all.

And right there Tommy understands what that silence means.

— Wait, he says quietly to himself. — Back then I was the one handing out trust. I kept saying “go ahead, I allow it,” without looking, just to avoid slowing things down. And now it came from the other side.

Tony does not skip the check because he waved it off. He skips it because proof is attached to the work, and there is nothing to check. Not because of charm, not because of luck, not because of “well, he seems okay.” Because of the fact. And that hit harder than any praise: for the first time, they believed him without taking his word for it.

A couple of minutes later, a line from Tony does come through. Not a review, not praise — a short, managerial note:

“Accepted. With this, I can actually sleep peacefully.”

And below it, as if in passing:

“I already get heartburn from ‘almost done.’ Too often it fell apart after that.”

Tommy smiles. All along Tony had been pushing “faster, do not over-polish” — and here he himself, without knowing anything about the night, had found exactly what Tommy had worked through with his hands: beneath a pretty “done,” it would not hurt to have a solid bottom. Tommy does not explain anything to him. He simply notices — even Tony reached the same thought by his own path.

6. How the journey ended

Oliver comes over. Not with the sour face with which he had been eyeing “magic” all month — he comes over simply, like to his own.

— Listen, later will you show me how these skills and plugins are set up? — he says, and for the first time in the whole month — no jab, just straight. — I want to see what you have under the hood. And I will teach you the old-school way — doing tasks by hand. Like we used to write code.

— Deal, Tommy nods. — You give me the AI kitchen, I give you craftsmanship by hand.

— Deal.

And then Tommy puts a box on Oliver's desk. Silently. Inside is a rubber duck, yellow, brand new, glossy.

Oliver looks at it for a long time.

— This is not Vaska.

— Well, Vaska is gone already, Uncle Oliver, Tommy says. — This is a different one. Whatever you call it, that is what it will be.

Oliver takes the duck out of the box, turns it in his fingers. For twenty years he had held the same one, only worn down to white patches. He sets it on a spot in the dust — exactly in place, his hands remember.

— Vasyok, — he says.

— Huh? Tommy does not understand.

— We will call him Vasyok. — Oliver moves the duck by a millimeter, straightening it. — Not Vaska. Vaska was one of ours. This one should grow up first.

He pulls out the drawer without looking, takes out a crumpled yellow can, and tosses it into the trash. And, already stepping toward the door, he throws over his shoulder — briefly, as if it means nothing at all:

— Thanks, Tommy.

Tommy freezes over the keyboard. Not “Tom.” Tommy. All month Oliver had kept him at a cold, formal “Tom” — as a stranger, as someone temporary, someone who would be carried out of here feet first any minute. And here — “Tommy.” Familiar, warm, the way people in the office call their own. One letter — and it was as if a door opened: the old man let him in. In it is their whole road, from the first dry “Tom” at orientation to this quiet “thanks” over the shoulder.

He sits there for another second, looking at the door that has closed. Not at victory, not at a parade — at the empty doorway and at his portal with the radar quietly glowing. And inside he catches not delight, but something else, unfamiliar. Even. As if the ground under his feet is finally not a slosh, but a floor.

He scrolls through this whole month in his head — from that brazen kid who barged in here with “come on, the AI will do it all, I will just press the button,” to who he is today. That kid grabbed things fast, lied to himself about “done,” and one night burned everything to the ground. And this one — today, alone, calmly, by habit — went through the full cycle from spec to proof, and the work was accepted silently, without a single question. Not because he got lucky. Not because he charmed anyone. On the merits.

And that kid is still there — he is the same hustler looking for where to cut a corner. He just knows now: you can only cut corners where there is a foundation under you. He did not stop being himself. He grew up.