Eugene Yan published a short post in May 2026 with a deceptively simple title: “How to Work and Compound with AI.” Inside is a five-step practice with primitive names that map onto operational disciplines most teams have not yet built. Provide good context. Encode taste as config. Make verification easy. Delegate bigger tasks. Close the loop.
The vocabulary matters. When you name a primitive, you make it ownable, schedulable, and auditable. The reverse is also true: what you cannot name, you cannot operate.
Read Yan’s list once and you will probably nod at three of the five. Context engineering is in the air. Verification harnesses are common. Delegation of larger tasks (multi-file edits, planning, code review) is what every coding agent already markets. Those three are the ones organizations are already building.
The other two are the ones organizations are skipping.
The two operational links most teams miss
Encode taste as config. Yan’s framing is operational: “each correction updates a config that reduces future errors.” Taste is not a personality trait of the senior engineer. It is a written artifact. Style guide, naming convention, security rule, brand voice, refactor pattern. The output of the corrected agent run becomes the input to the configuration that prevents the same correction next time.
Most teams treat taste as tacit. The senior reviewer fixes the same five things in every agent PR and never writes them down. That is not a review process. It is a tax.
Close the loop. Yan again: “every finished artifact becomes context for the next session.” Closing the loop is not a retrospective ritual. It is a context-engineering operation. The plan, the diff, the failed run, the corrected output, the rollback note: all of it becomes the seed corpus for the next plan.
Most teams treat the loop as a meeting. Wrong shape. The loop is a write operation against the agent’s working memory.
These are the two primitives that turn a fancy chatbot into a system that compounds. Without them, every session restarts at zero. With them, each correction shrinks the next correction.
Why the existing context-engineering literature doesn’t name them
The Azure SRE Agent and Manus playbooks (we have written about both) describe brilliant context architectures: KV-cache hygiene, hierarchical action spaces, externalized plans, file-system-as-extended-context. They tell you how to load, page, and compress. They do not tell you how taste enters the system or how artifacts return to it.
That is a feature, not a bug, of those documents. They describe single-session behavior. Yan describes the multi-session loop. The two views are complements, not competitors. You need the Azure-style RAM management to keep one session sane. You need Yan’s loop closure to make the next session smarter than the last.
If you have read our prior posts on context engineering and felt something was still missing, this is what was missing. The primitives that connect sessions.
Encoded taste as config: what it actually looks like
Five concrete forms we have seen work:
- Style files. Code style, prose style, naming style. Versioned, committed, loaded into agent context as part of system instructions.
- Refactor playbooks. “When you see X pattern, propose Y.” Written from the corrections the senior reviewer keeps making.
- Brand voice rules. Positive framing, banned words, watchlist terms. Written from marketing rejections.
- Security rules. Allowed dependencies, banned APIs, secrets handling. Written from the security team’s red-line list.
- Domain rules. “Customer X uses term A, not term B.” Written from the support transcripts where the agent got it wrong.
The discipline is not writing the rules once. It is writing the rule the moment the correction happens. Every PR comment that says “we don’t do it that way here” is a config write that did not happen. Multiply by 200 PRs per month and you have the cost of unencoded taste.
Operational test: when a new engineer joins, can the agent onboard them by reading the rules? If yes, taste is encoded. If no, taste lives in heads, and every head you lose costs you the rules they carried.
Loop closure: what it actually looks like
The shape is mundane, which is why people skip it.
After every meaningful agent run, three artifacts get written back to a known location:
- The plan that was followed (or modified mid-run).
- The diff or output produced.
- The corrections applied by the human reviewer.
Plus one more, often overlooked: the rollback or rework note. If the artifact had to be undone, why? Recording rollbacks prevents the next session from confidently rebuilding the same broken thing.
These four artifacts feed the next session. Not as a vague “memory.” As loaded context. The agent that starts the next session reads the last five plans, the last five rollback notes, and the active config files. The session begins with the residue of the last session already in working memory.
This is what “compounding” means in Yan’s frame. Not faster typing. Sharper starting point.
Where this connects to governance
The two skipped primitives are also the two that auditors will eventually ask about.
Encoded taste is the artifact a regulator can review to understand “what does this team mean by quality?” If your answer is “ask Sarah,” you are one Sarah-leaving-the-company away from losing your standards.
Loop closure is the artifact that proves the system learned from its mistakes. Every governance regime that matters (SOX, SOC 2, the upcoming EU AI Act enforcement waves) wants evidence of corrective action. “We fixed the same thing 50 times in 2026” is not a corrective action record. “We encoded the correction as config on day 3 and the error rate dropped to zero” is.
The teams that skip these primitives are not just losing efficiency. They are accruing audit debt.
Do this now
Pick one ongoing agent workflow. Code review, content drafting, customer email drafts. Anything where a human keeps correcting the agent’s output.
For the next two weeks, do two things:
- Every correction becomes a config write. Open the agent’s instruction file. Add the rule. Commit. Reload the agent.
- Every finished artifact gets logged. Plan, output, corrections, rollback notes. One folder. One file per run.
At the end of week two, count two numbers: how often the same correction repeated (should trend toward zero), and how often the new session asked a question already answered in the log (should also trend toward zero).
If either number is not falling, you have not closed the loop. You have just added a folder.
The five primitives are not equally hard. Context, verification, and delegation are tooling problems. Encoded taste and loop closure are discipline problems. Tools you can buy. Discipline you have to install.
This analysis synthesizes How to Work and Compound with AI (Eugene Yan, May 2026).
Victorino Group helps teams operationalize the two primitives most skip: encoded taste and loop closure. Let’s talk.
All articles on The Thinking Wire are written with the assistance of Anthropic's Opus LLM. Each piece goes through multi-agent research to verify facts and surface contradictions, followed by human review and approval before publication. If you find any inaccurate information or wish to contact our editorial team, please reach out at editorial@victorinollc.com . About The Thinking Wire →
If this resonates, let's talk
We help companies implement AI without losing control.
Schedule a Conversation