Define the end state, not the path
TL;DR. Workflow skill libraries like GSD and Superpowers turn the software development process into a chain of prompts: do X, then B, then A, and if C, do D. Nothing guarantees the agent follows it, and nothing outside the agent can check that it did. I uninstalled GSD and kept one Superpowers skill. What I standardize instead is the end state: a definition of done for the prose a repo holds, with every path left open.
Every few weeks another skill library promises to turn my coding agent into a disciplined engineer. At the time of writing, GSD has over 60,000 GitHub stars and Superpowers over 300,000, and the pitch is the same for both: install the process, and the agent runs it.
The libraries script the inner loop
Both map the software development lifecycle onto skills. GSD runs a six-stage cycle per phase (discuss, plan, execute, verify, ship, next milestone), each stage behind its own slash command, with state kept in a .planning/ directory. Superpowers chains skills that trigger on their own: brainstorm a spec, open a worktree, write a plan, dispatch subagents, test first, request review, finish the branch. Other libraries do the same with different vocabulary.
I'm not against skills. I use plenty of them, and I write my own. What these libraries share, and what I object to, is a whole modus operandi encoded as skills. Strip the branding and each one comes down to instructions like do X, then B, then A, and if C, do D. That is orchestration. It's a flow chart written in prose.
A path written in prose is a suggestion
A flow chart in code runs the same way every time. A flow chart in a prompt runs the way the agent reads it on that turn. The hand-off from one phase to the next is a sentence at the end of a skill, telling the agent what to do next. Whether that happens depends on the model, on how much context it has left, and on whether it already believes it's done. Nothing about it is deterministic. The process is at the mercy of the running agent.
Verification is the worse half. To check that a path was followed, I need the trace, showing whether the agent discussed before it planned and verified before it opened the pull request. The evidence is the agent's own account, plus artifacts the agent wrote itself. A plan file that says "verified" is the agent grading its own homework. Checking whether a repo ended up in the right state is a different job, because I can look at the repo.
We never gave engineers a script
Human teams solved this long ago, and not by scripting. We never made engineers follow a script for how to write code. One colleague writes tests first, another spikes a prototype and cleans up afterwards, a third lives in the debugger. Nobody minds, because the review checks the same things every time. We agreed on a definition of done.
That agreement is what lets a team work together at all. If every engineer verifies different things against different artifacts, there's nothing common to review against, and every merge becomes a negotiation.
Teams do adopt processes: Scrum, git-flow, review gates. Those coordinate between people, at the points where work changes hands. The inner loop, how one engineer gets from ticket to pull request, was always left free. Workflow skill libraries do the exact opposite. They prescribe the inner loop and leave the end state implicit.
Why GSD didn't fit how I work
My work doesn't come in one shape. Some of it is exploration and research, some is R&D where a task changes kind halfway through, and some is ordinary feature work off tickets. Some projects are fresh, and many I join mid-stream. I usually have several agents running in parallel, each on its own path, and I need all of them to converge on the same thing.
GSD assumes one shape. I installed it, and within a few weeks I'd stopped reaching for it. The on-ramp was all or nothing: running /gsd-code-review on an existing repository failed, because the .planning/ artifacts the framework expects weren't there. In practice, you start a project with GSD from day one or you don't use it at all. After a few weeks on hold I uninstalled it: 65 skills, 33 agents and 12 hooks. The agents weren't independent capabilities. Each one was spawned by a GSD skill and wired to its planning files, so without the pipeline none of them had an entry point.
From Superpowers I kept exactly one skill, test-driven development. It's a standalone tool. It does one job, it doesn't assume what came before, and it doesn't hand off to anything after. That's the shape I'd recommend to anyone: pick standalone skills and mix and match them to solve the problem in front of you. The sequence comes from the situation, not from the library.
ADS is my definition of done for a repo's prose
If I don't script the path, I have to define the destination. For code, that's long settled: CI goes green or it doesn't. Nobody had settled the same for the knowledge level, meaning the prose a repository holds. So every team, and every agent session, checked something different.
The Agent Docs Standard (ADS) is my answer for that layer. It distills what turned out to matter in my past projects, private and professional, about what a repo should hold besides code. It defines context, content, relations and the index: every module carries an AGENTS.md that routes to deeper docs, and those files link into a typed graph. Every kind of knowledge has exactly one home. Work state (status, sequencing, what's next) goes to the issue tracker and never into the repo. In the end, ADS answers one question: what prose do I commit, and where?
Here's the shape, from the standard's example project:
AGENTS.md
CLAUDE.md -> AGENTS.md
docs/
├── adr/0002-module-isolation-via-contracts.md
├── decisions/log.md
├── records/2026-08-14-bus-partition-alert-loss.md
├── concept/01-purpose-and-drivers.md
└── glossary.md
functions/
├── AGENTS.md
└── docs/references/event-schema.md
infra/
├── AGENTS.md
└── docs/runbooks/deploy.md
ADS doesn't care how an agent got there. One agent grills me before a design call, another builds a prototype first, a third works a ticket straight through. When each one is done, the decision it took sits in adr/, the incident it worked through sits in records/, and the trap it found sits in the module's AGENTS.md. Paths stay variable, and they all end in the same state. I can review that state the same way every time, and a linter checks its structure mechanically.
Where this argument is thin
An agent can ignore AGENTS.md as easily as it ignores a GSD skill. I won't argue against that. Prose is prose. Afterwards, though, a skipped step leaves no trace, while a missing decision record shows up as a gap in the tree.
The linter checks structure, not truth. It knows that an ADR exists and is well formed, not whether its reasoning holds. That still takes a reviewer, human or agent, but at least the reviewer knows where to look.
GSD is still better than having no process at all, especially for someone starting out with AI engineering who doesn't have a way of working yet. Adopting someone else's whole process is a reasonable first step. Don't start by building your own orchestration or tightening a setup whose limits you haven't felt yet. Those star counts come from giving people a process to lean on. My objection starts once you have a way of working of your own and the framework won't bend to it.
Skills are tools, done is the contract
Treat skills as tools you pick up, not as a process you install. Spend the effort you'd put into orchestration on writing down what done looks like, in a form you can check. How the agent gets there is its business. Whether it arrived is yours.