Earlier in August 2026, one of my AI agents swept my websites for broken links and found several dozen. Most had obvious fixes it applied on its own. Fourteen needed my judgment: redirect this old URL or retire it, restore this missing image or drop the reference. Every question was legitimate. The agent asked me in chat, one question at a time, and each question stopped its work until I answered.
Fourteen interruptions for one link sweep. Each answer required me to recover the context: which page, what alternatives, and how the choice fit the rest of the work. With several agents working on engineering tasks, those interruptions arrive from upgrades, triage, refactoring and operations at once. That cost compounds across concurrent work. This is a leadership problem as well as an interface problem.
Some of those questions can disappear through a clear standing instruction. An agent that already has authority to repair an obvious broken link needn't ask again. The remaining choices need enough context for a person to decide them. Sending each as a separate interruption makes related decisions hard to compare and leaves the answers scattered through chat.
In synthesis engineering, the discipline I've been building for rigorous, production-grade collaboration with AI, the direction dynamic keeps direction, judgment and verification with the human. The assistant executes delegated work, presents alternatives and supplies evidence. If every unresolved choice becomes its own conversation, the human becomes the bottleneck and the pressure to "just let the agent decide" grows. I want a workflow that makes careful decisions easier to sustain at speed.
I call that vehicle the Decision Packet: a self-contained HTML page, one row per decision. I open it like a checklist, work through the choices, add conditions in notes and return one summary. One sitting replaces the scattered interruptions, with my attention spent where my judgment changes the outcome.
Later implementation, September 2026: The technical details and downloadable exercise below use the linked September 27 source revision. Its specification binding and recorder were added after the August case.
Give each row enough context to decide
A useful row contains:
- The item in language its reader understands.
- The recommendation and the reasoning behind it.
- Evidence the reader can inspect.
- What happens if the recommendation is taken, and what happens if it isn't.
- Options whose labels describe the available outcomes.
- A note field for conditions or reasoning the buttons cannot express.
Rows can share options when the decisions really have the same shape. A row with different choices needs its own options. “Keep, with a named owner,” “Keep, and schedule a drill,” and “Remove” mean different things; reducing them to yes and no would lose useful information.
The page generates a summary that associates each answer and note with its row. Unanswered items remain present and marked undecided. The assistant can use that response to continue work within the authority it already has, while unresolved questions stay visible.
The generator is part of the open-source synthesis-skills collection. The following three scenarios illustrate the pattern; they are constructed examples.
An upgrade wave with a payments exception
A platform team needs its principal engineer's decisions on a service-upgrade wave. Most upgrades are routine. A few introduce breaking changes, and one service is under a payments freeze.

The example page starts with zero of eleven items decided. The marked recommendation is still unselected.
The engineer reviews the breaking changes against their diffs and holds the payments upgrade with the note, “not until the payments freeze lifts.” Once those exceptions have explicit choices, the engineer reviews the remaining routine set together. Work that would otherwise splinter across threads is handled in one pass, with the exception and its reason still visible.
There is a practical trap in the current interface: “Take all remaining” applies to every undecided row with a recommendation, regardless of the active filter. Selecting the “Routine” filter changes which rows are visible. It doesn't restrict the bulk operation to those rows.
That makes the order matter. Settle exceptions before using bulk acceptance, then check the remaining count and the full set of remaining items. If the batch mixes decisions that need different treatment, a separate packet for the routine set can be clearer than relying on a filter.
Feature flags that still serve a purpose
A quarterly cleanup turns up a long list of apparently stale flags. Many belong to experiments that have ended. Two still perform useful work: a payments kill switch and a regional consent gate.

The payments switch is normally off because it is an emergency control. Its age alone doesn't establish that it should be removed. The consent gate also needs a decision based on its purpose, not merely its time since last change.
The lead records ownership notes on the retained controls and holds a stalled experiment for a conversation with its former owner's manager. After resolving those exceptions, the lead inspects the routine removals together. The packet makes it possible to clear the accumulated flag decisions in one sitting while giving the dangerous rows individual attention.
Security triage needs evidence on each row
An open-source maintainer's assistant sweeps the advisories affecting her repositories and proposes dispositions: patch and release, document why an apparent match is a false positive, or record that the affected code occurs only in an example. Each proposal needs evidence tied to the relevant repository and usage.

This advisory and its stated reproduction are part of the constructed example, not a claim about a current package or vulnerability.
Here I'd use the packet to keep the evidence and decisions together while reviewing each advisory individually. The benefit is being able to compare the cases and retain the reasoning. A convenient bulk button supplies no reason to treat security judgments as routine.
The packet that I couldn't understand
Later that August, I closed out a research project on my open-source writing-quality skill with a fifteen-row packet. The first version collected zero of fifteen decisions. The buttons, filters and marked recommendations worked. The rows, however, used internal test codes, treatment vocabulary and corpus jargon that only the session that wrote them understood. My verdict was that it read as if “written in some alien or machine language.”
The repair was to write for the person arriving at the page. Name the reader, explain unfamiliar terms and state what each choice changes. One rewritten row read:
Idea: piling up metaphors instead of explaining
-> Keep in holding pen; test once more later

The historical research packet before selection.
I decided all fifteen in one pass after the rewrite. My browser blocked local storage that day, so nothing persisted between sittings; the paste-back summary still carried every decision. The design absorbed the persistence failure. Structure without comprehension had collected nothing; writing for the reader made the packet useful. A packet is a stranger-read document, and its reader arrives without your context, even when its reader is you.
The current generator supports part of that reader contract mechanically. With its --strict-reader option, it refuses a packet missing the audience or required consequence fields and checks for certain unhelpful option labels. A glossary is optional. Filling those fields cannot establish that the writing is clear, that every unfamiliar term is explained or that someone understood the choice.
The generator also rejects duplicate row IDs, a recommendation that points to no available option, and a packet with no recommendations. Those checks prevent inconsistent records; they don't tell the reader whether the proposed work is a good idea.
Before handing over a packet, have someone read a row without the originating chat and explain what each option would do. If they need the assistant's private shorthand translated, rewrite the row. The reader must be able to make the decision from what they've been given.
The discipline: Honest Defaults
Rule one: the recommendation is marked, never pre-selected. A fresh packet should show what the assistant recommends while leaving the answer unset. Otherwise, copying the page immediately produces a complete-looking record without anyone entering a choice. I reject that design on principle: a recommendation must not masquerade as a decision. Ballots don't arrive pre-marked. Code review tools don't pre-press approve.
The marked button draws the eye, and agreeing takes one click. An unset answer preserves the difference between a suggestion and a recorded choice. It also makes a partially completed review legible: one decided, two still unanswered.
Rule two: bulk acceptance is recorded as bulk. Thirty routine upgrades need not require thirty individual clicks when the reviewer has examined them as a set. The current control asks for confirmation and marks the affected rows as accepted in bulk. A later individual selection clears that row's bulk marker. The record preserves the method the reviewer actually used.
Those markers do not measure attention: someone can study every row before accepting the remainder or click one option without understanding it. The current summary's phrase “considered one by one” describes individual input; it cannot establish comprehension. Record the selection method accurately, then ask the reviewer to supply any reasoning or conditions that matter.
These two rules express what I call Honest Defaults: the integrity of the record outranks the convenience of the workflow. Human accountability is central to synthesis engineering, and I build its tools around that principle. Speed should come from batching, filtering and good recommendations while keeping the choices and their reasons visible. The payments exception, its note and the two bulk selections remain distinct in the record.
Keep the answer attached to the same material
Suppose a lead holds a payments upgrade until a freeze lifts. The assistant later changes the target service, an option's consequence or the supporting context. The old answer should not silently become a decision on the new proposal just because the row still has the same ID.
The generator computes a SHA-256 digest of the complete JSON specification. That covers its row labels, options, recommendations, context, consequences and declared scope. The page's storage key includes that digest, so saved choices for one specification are kept separate from choices for another.
The generated summary also carries the digest and each row's selection, note and bulk marker. The current recorder compares the supplied digest with the selected specification, checks the rows and options, and reconstructs the expected displayed summary. A mismatched specification or changed summary is refused.
This binds the response to the supplied specification. A link in that specification doesn't freeze the contents of a remote page. Preserve the evidence being reviewed too. The download below includes local fictional evidence files and checks their recorded hashes, so its stated source material can be inspected alongside the choices.
Browser storage remains a convenience. The Web Storage standard allows storage access to fail under relevant origin or policy conditions. The packet catches storage failures and can keep a summary in memory while reporting the persistence limit. A usable paste-back path lets the review continue when persistence is unavailable.
Work through three constructed choices
The offline packet exercise includes a generated page, its specification, three fictional evidence files, the pinned generator and recorder, a complete expected response and runnable checks. It requires no AI service. The automated interaction uses Node.js with a synthetic DOM and storage fixture; it does not operate a real browser or authenticate a reviewer.
There are three rows so the mechanism is easy to inspect. The tool normally asks for at least five; the exercise uses its explicit --allow-small option. For three ordinary questions, a conversation may be all the interface you need.
| Row | Proposed recommendation | Choice in the worked response |
|---|---|---|
| Reports service, version 1.0 to 1.1 | Upgrade the fictional service. | Take the recommendation through the remaining-row bulk control. |
| Payments service during a freeze | Upgrade during the fictional freeze. | Select “Hold payments until the freeze lifts” individually and add a note. |
| Emergency payments flag | Keep the control with an owner. | Take that recommendation through the same bulk control. |
Open the evidence first. On the payments row, select the hold option and enter “Keep payments unchanged until the freeze lifts.” At that point, the page should show one of three decided, with the other two still unanswered. Review both remaining rows and confirm the bulk action. The resulting summary should preserve the hold, its note, two bulk markers and all three row IDs.
For a separate check, start from an empty state and select “Routine only.” The page hides the payments and flag rows, but the bulk button still names three remaining items. Confirming it would select all three recommendations, including the payments upgrade. That is why a visual filter cannot substitute for settling the exception.
The README also explains the automated checks: an unchanged complete response succeeds; changes to scope, evidence context or consequences invalidate the old response; malformed or altered records are refused; blocked storage leaves the in-memory summary available. The tests compare the worked result with independently written choices and notes.
Corrected October 2026: the generator's license is Apache 2.0; this paragraph first said CC0.
The exact generator, recorder and upstream worked example are linked at the inspected revision. The current repository lists methodology/content skills under CC0 and executable skills under Apache 2.0; the download retains the applicable upstream license material. The broader practice is described at synthesisengineering.org.
Updated October 2026: A packet ends when the last decision is made, but the work it sets in motion often ends in steps only the human can take: staged messages waiting for approval, a logistics note to send from an app the agents can't reach, a call to make. Without a page of their own, those come back as one more long report. Their page is the action sheet: what's done, what waits for your approval and what's left for you, with the exact text ready to send yourself or to hand to an agent. It shares the packet's page engine and keeps its own rules, because a decision closes when it's made and an action closes only when it's done and confirmed.
Check authority before acting
A well-formed response does not authenticate the person who supplied it. The exercise's recorded output explicitly keeps identity unverified and authorization.granted false, even when the content matches exactly.
The action owner still needs the trusted instruction and the exact operation it authorizes. A choice about a proposed change doesn't automatically authorize publication, deployment, disclosure or deletion. Existing grants remain with their trusted source; a packet neither invents them nor revokes them. Consequential outward actions retain their own approval requirements.
If a button can't express the condition faithfully, use the note or return that row to conversation. The packet lets me move a batch of work forward without surrendering the record of my judgment.