Every sprint I have sat through ends with a retro. Gather in a room, say what went well, say what did not, write it on a board nobody reopens. Release day gets a postmortem too, eventually, when someone remembers to schedule it.
This one ran itself, on the cycle that had just finished, no calendar invite required. I felt the instinct the moment Ship closed: tell someone what you learned, write it down before the feeling fades into a vague memory of a lesson. The deploy had gone out. Quiet. Nothing broke. The rollback trigger I had written sat there unused, exactly the way it was supposed to.
This is Part 8 of The Contract. If you are new here: seven phases, a human approves every handoff, and Reflect is the last phase in that chain.
I expected Reflect to be the reward lap. Read back what happened, name the lesson, move to the closing part. It is not that. It made me answer a harder question first, before it let me write a single lesson down: what do I actually know, and what do I just remember feeling.
I already knew what the lesson was
Or so I thought.
One requirement in the notification queue had caused friction through the entire chain. Review had marked it partial. Nothing had broken. The queue introduced a call order and timing the requirement never described. Test found a real bug hiding inside that same gap, a timing issue that only surfaced once the check actually ran. Ship carried a rollback trigger for it anyway, written down, never needed.
By the time Reflect started, I had a conclusion ready. The risk register should have asked about ordering and timing from the start, not just field-level schema. Write that down, close the loop, move on to Part 9.
Reflect stopped me before I finished the sentence.
A candidate is not a lesson yet
The phase does not let you write a lesson directly into anything. It lets you propose one.
Every candidate gets a tag: propose-only. Not filed as knowledge. Not folded into anything a future feature will read as settled. It sits in a raw file, apart from anything curated, until I come back and promote it on purpose.
I wanted to skip that part. The conclusion felt obvious. I had lived the whole chain. I did not think I needed a waiting period to know what I had learned.
But nothing would have caught me if the guess had been wrong. Once a lesson is curated, the next brief reads it as fact. A diff gets reviewed again. A test run gets rerun. A curated lesson does not.
A lesson written the same day it happens is just a guess that got there first.
Reading the whole chain back, not remembering it
Reflect does not ask whether the feature works. Ship already answered that. It asks something none of the earlier phases had reason to ask. The whole contract has run once now, from the first brief to a deploy quiet enough to walk away from. What did the process actually cost, and what did it buy.
Answering that meant reading the chain back in order, brief through ship, one requirement at a time. Checked against evidence, not memory. The notification queue requirement had a paper trail by now: partial in Review, failing then passing in Test, shipped with a rollback in Ship. Reflect's only job on that line was to confirm the trail actually said what I thought it said.
It did, mostly. The trail also corrected me once. I remembered the rollback trigger as something Ship added late, a safety net bolted on right before the deploy. The trail showed otherwise. It traced back to Plan, to the same risk register that flagged the payload contract months earlier. Ship did not invent the trigger. Ship used what Plan had already written down.
I had been giving Ship credit that belonged to Plan. A small correction, the kind memory makes on its own until something forces it to check.
What the retrospective actually cost
The cost was patience, mostly. Writing a follow-up with a named owner and an actual artifact title, instead of a vague note to revisit the risk register someday. Sitting with a candidate tagged propose-only instead of calling it settled the day I noticed it.
What it bought was a retrospective I can trust the next time I open it, because it came from the trail, not from how the project felt in hindsight.
Eight parts in, the reflex has not changed: replace the feeling with a claim I can point to. Reflect was just the last place that reflex was waiting for me. Write down what you learned. You earned it.
Not yet. Propose it first.
One part is left. Closing will ask whether a contract this heavy is something I would run again.
What Reflect actually earns you:
Most retros produce a good feeling and a template. Neither one is evidence. This one does not let a lesson through until it has been checked against the trail, and that is the entire reason it belongs in your own workflow, not just mine.
The
reflectskill reads the full artifact chain, brief through ship, and builds a coverage retrospective for every requirement still active. It records outcome from evidence rather than intent. It proposes at most three learning candidates, tagged propose-only. And it will not let a follow-up go out without a named owner and a suggested artifact title.Give it to your agent on a task that has already shipped. It will not let you call something a lesson before you have checked it, and it will not let a clean result talk you out of naming what did not go well.
The retrospective it writes is proof the chain was actually read back, not just remembered fondly.
Top comments (0)