Skills changelog formalizes handoffs

Agent workflows are getting a little less magical and a lot more like real engineering. That’s the point of the latest Skills changelog from Matt Pocock — not just adding new commands, but turning the messy stuff between steps into named, repeatable work. The gap here is familiar: one agent plans, another codes, a human reviews, and somewhere in the middle the context leaks out. The new push is to treat that leak as a design problem, not a personality flaw in the model. ### What actually changed? The visible update is a new `/handoff` skill, plus a spotlight on `/prototype`. In the same changelog, Pocock also called out in-progress `/review` and several writing skills. That mix matters — it says the repository is no longer just about generating code faster. It’s about shaping the artifacts that let work move cleanly from one phase to the next. ### What does `/handoff` do? (youtube.com) Basically, it tells the agent to stop improvising and leave behind a usable trail. The GitHub skill description says `/handoff` writes a compact handoff document so a fresh agent can continue the work, suggests which skills the next session should use, and avoids duplicating material that already lives in plans, ADRs, issues, commits, or diffs. That last bit is the real idea — a handoff is not a diary. It is a pointer-rich transfer packet. ### Why is that a bigger deal than it sounds? Because most agent failures are not raw coding failures. They are coordination failures. Pocock’s repo frames the broader problem as misalignment, verbosity, and missing shared language between humans and agents. A handoff skill formalizes the moment where one context window ends and another begins. Instead of hoping the next run “gets it,” the workflow now has an explicit checkpoint. (github.com) ### What is `/prototype` really for? It’s for answering “should we build this?” before spending real implementation effort. The changelog describes `/prototype` as useful during planning and prototyping phases, and the surrounding repo activity shows it was added alongside documentation for interactive design work. In plain English — make the throwaway version first, especially when the uncertainty is in behavior, flow, or shape rather than raw feasibility. (github.com) ### Why pair handoffs with prototypes? Because prototypes surface ambiguity, and handoffs preserve what the prototype taught you. Without that pairing, teams often learn something useful in an exploratory session and then lose the reasoning when the “real” implementation starts. A prototype answers the unknown. A handoff carries the answer forward. That turns experimentation from a side quest into part of the delivery pipeline. This is an inference from how the skills are described together, but it fits the structure of the repo. (youtube.com) ### What about `/review` and the writing skills? Turns out those fill the same gap from the other side. The in-progress `/review` skill checks changes along two axes: standards and spec. In other words, did the code follow repo norms, and did it actually implement the intended work? The writing skills do something similar for prose — shaping raw material into clearer outputs instead of treating writing as an afterthought. (youtube.com) ### So what’s the pattern here? The pattern is artifact-first engineering for agents. Not just prompts, but durable objects — issues, PRDs, prototypes, reviews, handoffs, shaped writing. The repo itself now has more than 77,000 GitHub stars, which suggests this way of working is landing with a big developer audience. More importantly, it reflects where agent tooling is heading: away from one-shot genius prompts and toward small, composable skills with explicit boundaries. (github.com) ### Bottom line The news is not merely that four new names appeared in a skills catalog. It’s that handoffs, prototypes, reviews, and writing are being treated as first-class engineering outputs. That makes agent workflows less ad hoc — and much easier to scale without losing the plot. (youtube.com) (github.com)