Wordle is not interesting because the word is hidden. It is interesting because each guess creates a feedback pattern that cuts the search space. The green, yellow, and gray tiles do not only say whether a guess was right. They tell you what work is still worth doing.
A serious agent skill should behave like a good Wordle solver. It should make a move, observe feedback, partition uncertainty, pick the next artifact that removes the most doubt, and leave the reviewer with a packet instead of a mystery.
Wordle teaches the review loop
The simplest Wordle player tries to guess the answer. The stronger player tries to buy information. Binghamton researchers recently described a Wordle strategy that uses Shannon entropy to select guesses for information gain; BYU's ACME material explains the same idea as maximizing the entropy of the feedback result. This is the move software agents need to steal.
If an agent makes a hundred tiny changes, the next human question is not "can I read every line?" That question loses against speed. The better question is "what packet would collapse the remaining uncertainty fastest?" Maybe the packet needs a route map. Maybe it needs the exact commands run. Maybe it needs a contradiction table. The best next artifact is the one whose feedback partitions the review space.
Keep
The evidence proves this section. Lock it into the packet and stop rechecking it.
Investigate
The idea is present but misplaced. Move it into the right asset, script, or reference.
Reject
The claim does not survive evidence. Delete it, narrow it, or mark it as unproved.
Choose
Pick the next section by information gain, not by what is easiest to describe.
Three names for the operating system
The cleanest version of this pattern invokes three humans without turning them into decoration. Donald Knuth gives you minimax pressure: reduce worst-case confusion the way Mastermind solvers reduce the largest remaining bucket. John von Neumann gives you game strategy: every reviewer, future agent, CI gate, deploy path, and adversarial ambiguity is an actor with incentives. W. Edwards Deming gives you quality control: recurring review defects should become process gates, not heroic rereads.
This is why raw code checking is no longer enough for light-speed agents. Code review can still catch a bad branch, but it cannot by itself tell the next operator why the agent touched the blog, the search index, the skill reference, the asset template, the test, and the harness ledger. The packet has to bind those pieces into one inspectable game state.
Map the packet to Agent Skills
The Agent Skills spec
is small on purpose: a directory with required SKILL.md, plus optional
scripts/, references/, and assets/. That is
enough structure to turn review packets into repeatable software.
SKILL.md
Activation, invariant, workflow, and final gate.
Keep it short enough for startup and route users into references.
scripts/
Fill packet sections from evidence.
Use Python, SQL, TypeScript, Bash, or HTML where that language proves the section cleanly.
references/
Store dated reports, ADRs, source notes, and learning summaries.
Save weekly or iteration reports here so the next run does not re-ask what changed.
assets/
Hold templates, schemas, diagrams, and UI shells.
Make the review shape concrete enough that a script can fill it.
MCP can vend the UI. It is not the artifact.
MCP resources are application-driven, and MCP UI tooling can render HTML-like
resources through ui:// handles. That is useful. It is not the root of
the system. A review packet should still work as Markdown in a terminal, HTML in a
browser, JSON in a test, and an MCP UI resource in a host. MCP becomes a delivery
lane. The skill package remains the source of truth.
That is the point of putting consistent structure into assets/. The
template is portable. A Python script can fill the Markdown packet. A TypeScript tool
can mount the HTML packet. A SQL query can fill the evidence table. A host that speaks
MCP Apps can vend the same shell as ui://reasoning-quality-lab/review-packet.
If MCP is absent, the review still runs.
Apply it to this project
Chopshopr now absorbs this idea into its own reasoning-quality-lab
skill. The dated reference lives at
skills/reasoning-quality-lab/references/wordle-review-packets-2026-07-03.md.
The packet templates live at assets/review-packet-template.md and
assets/review-packet-ui-template.html. The renderer lives at
scripts/review_packet_builder.py. The catalog includes entropy
partitioning and minimax review as methods, so future agents can search for this
pattern instead of rediscovering it from the blog.
python3 skills/reasoning-quality-lab/scripts/review_packet_builder.py --format markdown
The review packet is the new board
The wrong lesson from fast agents is to make humans read faster. The right lesson is to change the review object. A code diff tells you what changed. A review packet tells you what the agent believed, what it touched, which gates ran, which uncertainty was reduced, what still fails, and where reusable learning was saved.
Wordle gives the rhythm: guess, feedback, partition, next move. Game theory gives the
pressure: design for the response you do not control. Agent Skills give the package:
SKILL.md, scripts, references, assets, evals, and receipts. Put those
together and the reviewer is no longer the harness. The packet is.