Most of the friction with a coding agent is not that it cannot write code. It is that it does not know what your project considers finished, what the thing is supposed to look like, or what you already told it last week. This week's launches are nearly all attempts to hand that shape over. Some turn repetition into skills, one gives the agent a design system it can actually read, two attack retrieval from the side of completeness rather than similarity, and the last three deal with how much output the agent reads and whether it is allowed to say it is done.
Skills that come from repetition
Skill Spotter is a Claude Code plugin that notices tasks you keep repeating and offers to save them as a skill you can run with `/name`. The detail that makes it more than a keystroke counter is that it compares what Claude did, not just what you typed: the commands, files and tools. So a rephrased request still counts when the steps stay similar, and the same request still counts when Claude takes a different route. It also spots multi-prompt workflows. When you keep adding the same rule to different requests, it offers to move that rule into CLAUDE.md instead, so you stop typing it. Everything it records stays on your computer, there is no telemetry and no account, and it uses no tokens per turn because suggestions are shown to you rather than to Claude. It never creates a skill on its own; you decide with `/skill-spotter:draft`.
App Factory is the same idea applied to a whole release pipeline, and packaged for sharing. It is a Claude Code plugin marketplace of 42 skills in eight opt-in tracks that build, describe, ship and announce apps to the App Store, Google Play, and directly on Mac and Windows. Opt-in matters here: you enable the tracks a repository needs, and a session opened in that repository carries them, while a session opened anywhere else does not. The skills run ordinary command-line scripts, including `check_name.py`, which audits a name against the live App Store, and `measure_copy.py`, which catches a translation that dropped a claim. QUICKSTART walks the whole thing in about fifteen minutes for one app. The honest caveat is in the README: it is built for Claude Code and tested only there, because most skills find their scripts through `CLAUDE_PLUGIN_ROOT`, which only Claude Code sets.
A design system the agent can read
Better Design goes after the complaint that agent-built apps look AI-made. It is a design system for AI coding agents: you run `npx better-design` in your project, it resolves a registry, writes globals.css and adds components to your components/ui directory. What makes it genuinely agent-friendly is the documentation. The index is served at `/llms.txt`, and every page is also available as Markdown, either by sending an `Accept: text/markdown` header or by adding `.md` to the page URL, so an agent can read the system instead of guessing at it. The pitch is concrete: new features slot into the same system rather than each screen being a fresh fight, and the app reads as one product instead of a set of screens that each feel different. The components come from a hosted registry, which is worth knowing before you depend on it.
Retrieval that aims to be complete
Limma is an MCP server for company data, and its argument is aimed squarely at chunking. The page puts it plainly: chunking and retrieval were built for reading, not for answering completely. Documents get split into fragments and fetched by similarity, which is a good way to find something worth reading and a bad way to be sure you found everything. Limma instead reads your documents and data, builds a structured map of every detail in them, and gives your agent the complete answer with proof. Its four numbered objections are the useful part of the page: similarity is not a filter, meaning breaks at the boundary so a fact spanning two fragments survives in neither, the slice stays the same size no matter how much data you connect, and nothing reports the remainder, so an incomplete result and a complete one arrive looking identical.
Hashgrid DNA attacks the same area from the feedback side. It is a search engine that learns: you send one embedding per item from any model, DNA finds the best result, and every score you send back trains it on its side, so you host or tune nothing. The API is small on purpose. You populate with one embedding per item under a key you choose, you search, and you send a score when you have one. That score can come from an LLM, a small model, or your own users, and nodes can be tools, products, documents, people or anything else you can name. One honest detail: the counters on the landing page are described by the site itself as illustrative of the mechanism, not a measurement.
Whether DONE was earned
Truth Firewall starts from the sentence every agent user has read: "Done. Tests pass." Maybe it is. Maybe a requirement was skipped, maybe an edge case is broken, and then you check everything anyway, which defeats the point of having an agent. Truth Firewall independently verifies your acceptance conditions before accepting DONE, and returns one of VERIFIED_DONE, REJECT_DONE or HUMAN_REQUIRED. On a rejection, Codex keeps working. You install it with pipx on Python 3.11 or newer, and a demo runs offline without a Codex account. Two limits are stated up front: authenticated Codex execution in 0.1.0 is a Windows-only pilot, and you still have to write the acceptance conditions yourself.
Less to read, and a safer way to move
Squeeze is the smallest idea here and possibly the most useful. It reads a tool's output on stdin and prints only what an agent acts on: every change, failure and decision, plus a note naming what it cut. It detects the format, so you just pipe, and the README's example is vivid: 6,294 bytes of terraform plan JSON become 485. You tell your agent by adding a line to AGENTS.md or CLAUDE.md, and when the compaction is too aggressive you rerun with the flag squeeze names, such as `--max-attrs 0`. There is no release yet, and the output can change until 1.0.
Ecsodus handles a migration most teams would rather avoid. AWS ended support for the Copilot CLI, and Ecsodus migrates those apps to Terraform-managed ECS in place, with no downtime and no data loss: inventory, report, generate, retain-patch, import, teardown. The ordering is the point. Read-only steps come first, retain patches are applied so teardown cannot delete what was imported, and the Copilot stack is removed only after the import has been verified. A documented end-to-end run reports 44 of 44 imports and zero data loss. It needs Terraform 1.10 or newer and Python, and it does exactly one migration.
The thread running through all eight is that none of them make the agent smarter. They make the project more legible to it, and they make its claims about being finished something you can actually check.