New AI Coding Workflow: Spec, Tickets, and Wayfinder
Most AI coding assistants fall apart the moment a plan gets too big for one session. You start strong, then lose track of decisions, tickets stay vague, and the agent starts guessing instead of asking. This is exactly the friction a recent update to a popular open-source skills repo sets out to fix. The maintainer (Matt Pocock) just shipped version 1.1, and the changes reshape the AI coding workflow that developers use with these skills — from renamed core skills to a brand-new system for planning work that’s too big to fit in a single context window.
Why PRD Became Spec, and Issues Became Tickets
Two of the repo’s core flow skills got new names in this release. to-prd is now to-spec, and to-issues is now to-tickets. The maintainer says this had been bothering him for a long time: what the old “PRD” skill actually produced wasn’t a product requirements document. It was a broader specification that could cover technical details, non-technical context, or both. “Issues,” meanwhile, always felt biased toward GitHub and Linear, when the real unit of work underneath a spec is simply a ticket.
The rename does create one bit of friction: the skills installer won’t automatically migrate old PRD or issues skills to their new names. Anyone updating needs to run npx skills add, pick the renamed skills deliberately, and then clean out any leftover old-named skills from their skills folder.
The Core AI Coding Workflow: From Spec to Shipped Code
Version 1.1 also turns what used to be a planning-only process into something closer to a full development lifecycle. The sequence now runs: a grilling session (an agent interviews you instead of you writing a plan) produces a glossary and architectural decision records, those feed into a spec, and the spec breaks down into individual tickets so work can spread across multiple agent sessions.
A new implement skill sits at the execution end of that chain. Its instructions are short: implement the work described in the spec or ticket, use TDD where possible at pre-agreed seams, run type checks and single test files regularly, run the full test suite once at the end, then call code review and commit. The maintainer says he almost skipped building this skill because the logic seemed too simple, but enough people kept asking “what’s the flow?” that making it explicit turned out to be worth it.
Code Review Now Hunts for Fowler’s Code Smells
The code review skill, which graduated out of “in progress” status in version one, checks code on two axes using parallel sub-agents. One axis checks whether the code follows the repo’s documented coding standards. The other checks whether the code faithfully implements the originating spec or ticket.
The standout addition is a set of code smells pulled directly from Martin Fowler’s Refactoring: mysterious names, duplicated code, feature envy, data clumps, primitive obsession, message chains, and more. Because these terms are already deeply embedded in most models’ training data, simply naming them in the review prompt is enough to get the agent to spot and name the same issues in your code — “I found some message chains,” for example. The maintainer tested this for a couple of weeks and calls it outrageously useful for a change that added roughly ten lines to the skill.
Wayfinder: A New Skill for Planning Big, Foggy Work
The most significant addition in this release is Wayfinder, a skill designed for situations where a plan is too big for one agent session or risks blowing past the model’s context window. Instead of a single planning conversation, Wayfinder charts the plan as a shared map stored directly in the repo’s GitHub issues, then works through sub-issues one at a time until the route to a finished spec is clear.
Each sub-issue is scoped to fit one agent session and labeled by type: research (an AFK task where the agent investigates and reports back), grilling (a decision that needs a conversation with you), prototype (a cheap, concrete artifact used to raise the fidelity of a UI or logic discussion before committing to a spec), or task (routine setup work that doesn’t need a decision). Sub-issues carry blocking relationships, so the agent can’t make a downstream decision before an upstream one is resolved. Once every ticket on the map closes, the whole thing rolls up into a regular spec. A small companion research skill spins up a background agent to investigate a single question and write findings to a markdown file, matching whatever note-taking convention the repo already uses.
The maintainer also simplified the TDD skill in this release. It’s now reference material rather than a rigid script: write a failing test before the code that makes it pass, one slice at a time, and leave refactoring out of that loop entirely — it now belongs in code review instead.
Key Takeaways
- The skills repo renamed “PRD” to “spec” and “issues” to “tickets” because those names better describe what each artifact actually is.
- The core workflow now runs grilling, spec, tickets, implement, and code review in sequence, with a dedicated implement skill added purely to make that flow explicit.
- Code review runs two parallel sub-agent passes, one checking coding standards and one checking spec conformance, and now names Martin Fowler’s code smells directly to sharpen the agent’s critique.
- Wayfinder is a new skill for planning work too large for a single agent session, storing the plan as linked GitHub issues typed as research, grilling, prototype, or task.
- The TDD skill was simplified to reference material covering only “red before green,” moving refactoring into code review instead of the implementation loop.
Version 1.1 is not just a naming cleanup. It turns a loose planning process into something closer to a real software development lifecycle. Renamed skills cut down on ambiguity, the implement-and-code-review pairing enforces more discipline, and Wayfinder gives large, foggy projects a structured path forward. If your AI coding workflow keeps stalling on big tasks, this update is worth adopting.
