Spec-driven AI development doesn't have to reinforce the feature factory
Since September 2025 I have built the things I need with spec-driven AI development. An agent turns a conversation into a spec, another builds it, and a third reviews it before it merges. I am not a developer, and for me this way of working has been revolutionary. It can also make a feature factory very efficient. But with some additions, it can instead help us stay outcome-focused.
This week Matt Pocock’s skills arrived in a client’s repository ahead of an AI workshop. I had the same reaction to them that I had when I first installed superpowers, another set of skills for planning and building with Claude Code. Both sets are made for developers, and I have no comments on the development side. What I noticed is what they leave out: the outcome.
Both skill sets hold the code to the spec
Pocock’s implement-spec skill states its goal as “the entire spec implemented on a single integration branch, with every ticket resolved the way the issue tracker closes work.” Superpowers checks its plans for “Spec coverage” and asks of every requirement: “Can you point to a task that implements it?” Both sets hold the code to the spec, and neither asks whether anyone behaves differently once the feature is live.
That change in behaviour, and the number that shows it, is what I mean by the outcome. Used that way, the agents count what ships, which is how a feature factory works.
Superpowers comes closest to the outcome: its brainstorming step asks for “the intended outcome, who it is for, and what success looks like.” But neither set has a place for the behaviour that should change, so nothing carries it from the spec into the build or the review.
Product decisions deserve a record like architecture decisions
Pocock already solves the same problem for architecture. His skills keep short decision records, and his format explains why: “These stop the next engineer from “fixing” something that was deliberate.” A decision record is short, versioned, and says why, so the next person, or the next agent, can read it before they change anything.
Product decisions deserve the same treatment. What if a product decision record held the outcome definitions, the guardrails and the choices we have made for the product? Developer specs could reference it, and agents could look out for it while they plan, build and review. For scilla.studio’s benchmark tool, it could read like this, with our own numbers in the brackets:
- User: product people and founders who want to compare their growth numbers.
- Behaviour: they generate a diagnostic report of their numbers, and then do something with it: share it or download it.
- Outcome: increase the share of people who share or download their report from [baseline] to [target] by [date].
- Guardrail: nobody needs an account to use it.
Generating the report is the aha moment. Sharing or downloading it shows that the report was worth something.
What AI can do with the outcome on record
With the desired outcome on record (who the user is, which behaviour should change, how we will see it), AI can take it one step further:
- Before the build, it can test every user story against the outcome and drop the ones that would change nothing.
- During the build, it can add tracking for that behaviour in the same tickets, so the measurement ships with the feature.
- After release, the product manager has the outcome on record, versioned next to the code, so AI can pull the number for them on the date they set.
Without the record, the work ends when the code ships:
With it, what we measure goes back into the decision:
The outcome gets lost at the handover
But isn’t the outcome the product manager’s job, settled before anyone writes a spec? It is, and these are engineering tools that make no claim to do product work. My hypothesis is that the outcome gets lost at that handover, because the agents build from the spec and the spec has no place for it. Recording the product decisions where the spec can reference them leaves the decisions with the product manager and puts them in front of the agents that build and measure.
What I’m testing with Matt Pocock’s skills
This is what I’m testing right now with Matt Pocock’s skills:
- A
product-foundations.mdfile sits next to his glossary and his architecture decision records. It holds, for example, the outcome, the problem the product solves and for whom. - A new skill checks a piece of work against that file: which user group it is for, and whether it would move the outcome. It runs on its own, and three of his skills call it.
- His grill-with-docs skill calls it before anyone writes a spec, to ask whether the work is worth the time for the outcome.
- His to-spec skill calls it to write an Outcome section that points at the product file.
- His code-review skill calls it to check a third thing next to the coding standards and the spec: whether the change serves the outcome.
The product file
product-foundations.md sits at the repo root, next to GLOSSARY.md and docs/adr/. It holds the outcome, the problem, the user groups and their use cases. The product manager owns it. Pocock’s setup skill has a file called domain.md with a list headed “Before exploring, read these”, and I add the product file to that list. If the file is missing, the skills proceed silently, the same way they do without a glossary.
The new skill, check-outcome
It reads the product file and puts three questions to the developer, one at a time like grilling. Before each one it proposes its own reading: “This looks like it’s for [user group]. Is it?” The questions:
- Which user group and use case is this for?
- Which behaviour in the outcome should it change?
- Which event or number would show it?
The developer answers, and the skill does not judge the answer. If the developer doesn’t know, that becomes an open question for the product manager.
grill-with-docs
Today the whole skill is one line: “Call the Skill tool twice, for “grilling” and “domain-modeling”.” I add check-outcome as the first call. If the work doesn’t move the outcome, the conversation starts there, before anyone writes a spec.
to-spec
It takes the answers from the conversation and does not ask again, which fits a skill that says “Do NOT interview the user”. The template gets a new section, Outcome, between Solution and User Stories. It holds the behaviour, the user group and the event to track, so the tracking ships in the same tickets. The actor in each user story is a user group from the product file.
code-review
Today it runs two sub-agents in parallel, Standards and Spec. I add a third, Outcome. It asks nobody. It compares the diff with the spec’s Outcome section and the product file, and reports three things: whether the change serves the behaviour, whether the tracking is in the diff, and any functionality for a user group the file doesn’t name.
It gets its own heading in the report and is not ranked against the other two, which is how Pocock keeps Standards and Spec apart. If the spec has no Outcome section, the sub-agent is skipped and the report says so.
What stays with the product manager
Following up on the number after release, and updating the outcome.
What it looks like in the benchmark tool
An example from my benchmark tool. The outcome is to increase the share of people who share or download their report. A developer adds a “copy link” button. In grill-with-docs, check-outcome gets the answers: product people and founders, sharing the report, the event report_shared. to-spec writes those into the Outcome section. Then code-review flags the missing report_shared event, or an investor view built in the same change, since investors are not a user group in the file.
The check I care most about runs in grill-with-docs. It makes us decide, before we start, whether the work is worth the time.
Outcomes change as we learn
Outcomes change as we learn, so a changed outcome becomes a new version of the record. Sometimes a cheap test before the spec answers more than a build would. Much of this is product operations: artefacts that need a home, and a process that is intertwined with the build process. Let’s not fumble the opportunity to build the system so that it helps us stay outcome-focused, instead of reinforcing the feature factory.