There Is Probably no Spec
On the documents I never trusted, the last mile everyone’s automating, and a system built for people who can stand not knowing yet
I have never written a PRD I believed in.
I’m telling you this because I built a thing, and now I have to explain why, and this is the part where a perfectly normal person starts to sound like a man in a linen shirt saying “operating system” at a retreat. So let me get the confession out first, before the pitch. The thing is small, it’s on GitHub, it’s for the kind of product work that happens after reality touches the product. We’ll get there. But it starts with a document I never believed in.
Proud of, sure. Proud the way you’re proud of a drawer you finally organized — socks paired, chargers coiled, a zip-lock bag of screws you’ll never identify but can’t throw away, because throwing them away feels like tempting God. Believed in, no. Because a PRD isn’t a document. It’s a treaty everyone has agreed to nod at because the meeting has to end. And it’s always vaguest in the exact spot where the real thinking was supposed to happen — what we’re deliberately not building, where the architecture bends, what the customer will do that nobody pictured. That paragraph is written in the softest, most hopeful prose in the whole file. Horoscope prose.
I clocked this in my first weeks as a PM, before I had the standing to find it weird. Someone told me to write the corner cases. We had QA. People whose whole craft was watching things break in dimensions I didn’t have eyes for — people who could look at a login form and see four ways to take down the database and a legal problem besides. And I was supposed to sit alone in a Google Doc and out-imagine them? Invent worse edges than the professional edge-finders, from memory, with a coffee?
So I didn’t. I gave the corner cases back to QA. I let engineers own the architectural trade-offs, because the trade-off was the decision and they were holding it. Also, frankly, an architectural trade-off is a letter an engineer writes to himself a year from now, and I’d rather not sign my name to someone else’s future correspondence — least of all when I don’t know what duct tape and broomsticks the code is balanced on down there. I had designers talk to engineers directly, instead of routing every sentence through me like a customs official stamping crates I couldn’t open.
For an embarrassingly long stretch I thought this was a flaw I was getting away with. Real PMs wrote the doc, owned the spec, held the line — held it against what, I never asked. I pictured a line, and me, holding it, and on the other side, I don’t know. The roadmap? Entropy? Weather? I just couldn’t do it, and I assumed the not-being-able-to was the shameful part.
Took me years to notice it wasn’t a flaw.
It was a position I’d never bothered to argue for.
So.
I hate tickets. I hate PRDs. I hate handoffs. I hate the Figma lobbed over the wall with a little build this, like a note tied to a brick.
And it isn’t laziness, though I’ve let people believe that, because “lazy” is a much cozier thing to be than what I actually am. Every one of them lies about time. Each pretends something got decided — that there’s a spec, a design, a strategy sitting in a stable state, finished, signable, handable to someone who wasn’t in the room. There is no stable state. The spec went stale before the meeting ended. The design assumed a user who, it turns out, does not exist and never did and is, if anything, mildly offended you imagined him. The strategy was a Tuesday morning’s mood in a good light. By lunch we believed something else and didn’t tell the deck. Nobody ever tells the deck. The deck is out there right now, in a meeting, being presented, radiant, wrong.
And now they’ve killed the PRD and handed PMs a prototyping tool, like that’s the cure. It isn’t. A throwaway prototype is just a PRD that learned to click. Same lie about time, now with animations. And the animations are the tell — bells, whistles, a tasteful loading spinner, all of it busywork pretending to be thoughtful decisions, all of it hiding the same empty paragraph the PRD at least had the honesty to leave empty. The doc left the hole visible. The prototype paints over it and calls the paint a demo. The one question that mattered — what happens when the catalog data is dirty, what do we not build — never comes up, because the thing moved and moving things feel finished. Horoscope prose with a dribbble account.
Nothing holds still. I spent years treating that as a personal failing — get it together, pin it down — before I noticed it isn’t a thing you pin down. It’s the weather. And the weather’s been dramatic lately: a model drops on a Tuesday and by Thursday the entire industry is standing in the parking lot watching its old assumptions burn. The ground moves weekly. The page swears, hand on heart, that it doesn’t. And that gap, between the moving ground and the very still page, is where products go to quietly die. Sorry — loudly die. Usually in a QBR.
So here is the thing the whole ritual is engineered never to say. It belongs on the side of a London bus, in the Dawkins font, ideally passing a WeWork full of people writing acceptance criteria — There’s probably no spec. Now stop worrying and ship the thing. No deck that holds, no design that survives the week, no blessed moment where the thinking is finished and we simply, peacefully execute. It all moves. All the time.
And that — I really can’t stress this enough — is not the tragedy.
That’s the job.
For three years we took all this magnificent automation and aimed it, with great precision, at the end of the process. Write the PRD faster. Generate the ticket. Produce the user stories. Summarize the call. Add tags. The last mile — the stretch where the thinking is already finished and you are merely typing it up — that’s the part we sprinted to optimize.
Which is backwards, because the typing was never the slow part. The slow part, the expensive part, the part that actually decides whether the product lives, sits all the way up the funnel in the question of what is worth building at all — and that part we touched not at all. Automating the output to ship faster is buying a faster printer to write a better novel. Jira can now be cleaner, longer, and slightly more emotionally available. But I keep wondering which product actually failed because the PRD wasn’t long enough. Which strategy died because the ticket missed its seventeenth edge case. Which team collapsed because an engineer had to ask another human what the work meant.
I understand the appeal. The output is the one stretch that doesn’t require you to sit inside we don’t know yet, and the human brain, offered the choice, will do nearly anything rather than sit there. It will reorganize the backlog. It will rename ticket tags. It will schedule a meeting to prepare for the meeting.
Because a roadmap is a probability tree in a business suit. You make a bet; yes or no splits the world in two; each half sprouts its own little bets; those split again; and by Q3 you are standing in front of fog with a Gantt chart drawn on it, presenting the fog, coloring the boxes, pointing at the blue ones as though they signed something. Everyone in the room can see it’s fog. Naming the fog is not a career move.
I used to ask one question whenever someone ran an experiment — what do we do if it comes back green? red? grey? — and the silence that followed was, every time, deeply educational. Usually there was no answer, because the experiment was either a toy we’d discard having learned nothing, or a feature we were shipping regardless of the result — in which case, friend, that is not an experiment. That’s a gradual rollout with extra steps and a prayer.
We are probabilistic machines that cannot stand being probabilistic. So is the model, incidentally — same fog, same guessing. The difference is the model has the decency not to pretend it decided.
The next stretch belongs to whoever can live inside the not-knowing-yet and act from in there anyway — not to whoever automates their way out of the discomfort. The discomfort was the one thing still telling you that you were up the funnel, where the value is.
If the thinking never lived in the document, you have to ask where it went — and the answer is annoying, because it means it was never written down at all. It lived in the conversation. Always — not in one head, which produces nothing but a person nodding to themselves, but in the gap between two people looking at the same thing and seeing a different thing, which is where every real idea comes from and also every divorce. The write-up of the argument is not the argument. The write-up is the taxidermy: right number of legs, eyes forward, dead.
External too. Market knowledge, which we pronounce like geology — a vein of it somewhere under Gartner, waiting for a sufficiently expensive consultant — when it’s just another conversation that won’t stop talking: competitors, customers, the prospect who ghosts you, the technology rearranging itself under your chair mid-sentence. Our institutional response is to answer it four times a year, badly, in a slide we call Market Landscape, as though the landscape would hold a pose.
So if you go looking for the value, it’s never in the strategy doc. It’s in the call transcript. The field note from the deployment that caught fire and taught you more in an hour than the roadmap did in a quarter. The Slack thread where two engineers fight about an architecture at a temperature that would, in any other department, summon HR — and should in this one too, except that thread is the smartest thing anyone wrote all quarter. The half-sentence a customer says with one foot out the door, the one that explains why the feature isn’t trusted even though everyone keeps calling the problem onboarding — worth more than the deck you built to impress them, which they didn’t read.
And we save none of it. The transcript deletes in ninety days, the Slack fight scrolls into the abyss, the customer’s line gets a “haha did you catch that” and enters witness protection forever. The most valuable material this company will ever produce, and our archival strategy is the memory of whoever was on the call and isn’t on PTO.
Here is the strange part. For the first time, a lot of this is actually captured. Transcripts exist. Calls are recorded. Slack can be searched, at least in the technical sense in which a landfill can be searched. And what do we do with it? We ask for a meeting summary. We ask for action items. We ask Granola what someone said about pricing. Action items are the carrots of corporate life: small, orange, theoretically good for you. But it’s such a small ambition. We discovered electricity and used it to label candles.
Because the unit that matters — watch how small it is — is not the event. The event is a log line. The agent recommended a winter coat to the swimwear category. Inert. And it’s not the judgment either, the take rattling around someone’s skull — I think it’s the variant matcher — worthless, and worse, unsaved. The unit is the two welded together: the agent miscategorized swimwear, and I’d bet it’s the variant matcher reading the fallback attribute again, same smell as that mess at the other account. That. A person who was nowhere near the call can pick it up and test it. Without the interpretation, you have a log. Without the event, you have vibes. Product teams already have enough vibes to heat a small city. The welded thing is the whole job.
And nobody saves that one either. Not laziness — saving it just isn’t anybody’s job. It’s not a ticket, not a deliverable. There’s no swimlane labeled things a person briefly understood. So it evaporates, daily, in every company on earth, while we go back to mining the slide called Market Landscape.
The system
So I built one. And I know exactly how that lands — someone builds a system, writes a manifesto about the system, and the system turns out to be four markdown files and a dream. Fair. Hold that suspicion. You may need it.
The obvious way to describe it is the wrong way, which I know because I have now written this section wrong four times, each time with total confidence.
The wrong way: six clever skills producing six clever artifacts. They don’t. They produce deliberately stupid ones. This trips people, so, plainly — I do not believe in a system that replaces human judgment. I believe in one where human judgment converges. The skills are dumb on purpose. Each is a clean glass you pour your judgment into, and the system’s only talent is carrying the glass to the next person before it evaporates. The intelligence is you. It always was — there’s no skill in here doing your thinking, now stop worrying and do it. The tool merely declines to let what you thought go cold in your own skull before anyone else can use it.
Funny consequence: the more of yourself you pour into a debrief, the better it gets. A debrief written like a court stenographer — just what was said, faithfully, uselessly — is worth almost nothing. The customer was concerned about setup complexity is not nothing, but it’s close. A debrief where you say what it meant, what spooked you, what you’d bet on — the customer said setup complexity, but I think they’re afraid the system will make decisions they can’t explain internally, same fear we saw at the other account, so the problem may not be onboarding, it may be trust — that’s the gold. The skill doesn’t think for you. It refuses, politely, to let your thinking go to waste.
The skills live exactly where context gets made — the points of dialogue — and they run into each other:
debrief rides customer calls. journal rides internal syncs — where the company accidentally tells the truth and then immediately forgets it. signal catches the loose field observation that would otherwise die in a notes app titled stuff that works (maybe). assessment and status ride the prep — are we ready, what’s actually true about this account, because readiness is a polite fiction until someone says what’s true. truth-sheet is the synthesis, one living reference per product that everything pours into and out of. Nothing is a dead end. A debrief corrects a truth sheet; the truth sheet reshapes the next assessment; the assessment changes the next deployment; the deployment throws sparks that correct the truth sheet again. A loop, on purpose — because the straight line, input-output-done-next, is the shape of work that forgets everything the instant it finishes.
What holds the loop together is the one rule I will not negotiate on. Every artifact ends the same way:
That middle line is the entire religion in three words. Upstream corrections makes every new piece of judgment confess what it just killed. We thought customers cared most about automation speed; this suggests explainability. We thought onboarding was the blocker; this deployment says internal trust. We thought the feature worked for enterprise; this escalation says it works when the catalog data is clean, which is to say, in the brochure.
This is the difference between documentation and memory. Documentation says: here is what we wrote down. Memory says: here is what changed. Nobody wants the soul-flattening job of keeping the docs current — that job is so spiritually flat it should come with hazard pay, and so it never gets done. So there is no such job. There is only the next observation, naming what it just made false. That’s smaller, and because it’s smaller, it has some chance of actually happening.
I genuinely don’t know why it’s six. People want the number to mean something — six, like a covenant, like there are tablets. It doesn’t. Nothing here came down from Sinai. Six is how many places I kept finding dialogue I didn’t want to lose. A seventh earns its way in, it’s in. I’m not religious about the shape. I’m religious about not losing the thought.
You can have it
Last time I said that if enough people wanted it, I’d open-source the whole thing. Enough did. So here it is — six skills, the config, an install script, one fictional account run end to end so you can watch judgment travel through the machine and come out the other side still warm.
I called it FDOS. Half the joke is that it sounds like an operating system your dad ran in 1987, green text on a black screen, a beige box humming under the desk. The other half isn’t a joke: it is an operating system, just not for a computer. FD is forward-deployed — the engineer they embed inside the customer to watch the product break in person, because nothing teaches you like watching your thing misbehave three feet from the human it betrayed. That’s the whole posture. Not the PM writing specs at a safe distance, but the judgment that lives forward, in the field, where it’s still warm. An operating system for that.
MIT. Fork it, gut it, rip out the footer protocol and bolt it onto whatever you already run, build something you charge actual money for and pretend it came to you in the shower. The code is not the valuable part. The argument is — and you can’t put a license on an argument, which is the one comforting thing about having spent three years on it.
It’s built for teams where the product’s truth changes the second it touches reality — complex B2B, enterprise AI, forward-deployed work, where Sales and Success and Product and Engineering are each holding a different part of the elephant and calling the elephant a roadmap. If that’s your world, this might help. If your world is tidy and self-serve and the documents genuinely hold — if nothing in here has made you wince in recognition — then you don’t need it, and honestly you should be a little suspicious of how calm it is in there. I hope the chairs are good.
Now let me show you where it breaks. Because it breaks, and I’ve been strolling past the spot this whole time calling it scenery.
It runs on discipline. Which is a generous word for a tired person at six in the evening, after the fourth call, choosing to type instead of going home. That’s the engine. A specific exhausted human deciding their own thought is worth the keystrokes, while the thought cools.
My first instinct was the stick. Make it mandatory. Wire it to the review. Give it teeth. And there — right in the reaching for teeth — you’ve rebuilt the ticket. Congratulations. The ticket works because it bites you in standup. But bite a debrief and it stops being a debrief. It becomes a hostage statement: complete, faithful, terrified, saying nothing. The person writes what happened, because what happened is safe. They do not write what they think, because what they think can be wrong, political, premature, rude. You cannot scare a person into telling you what they think.
So you can’t force it. You can only make it so light nobody notices they’re lifting. And here’s the part where I stop knowing things — out loud, on the record.
Maybe the transcript files itself the second the call dies, and all that’s left is the half that was ever yours — the bet. Maybe it’s voice, not keyboard — you’ll say to your windshield what you’d never type, the mouth being a door and the keyboard a wall with a Post-it on it reading later. Maybe the system quits holding out an empty glass and asks something rude instead — swimwear. again. your bet? — on the theory, fully unproven, possibly invented to soothe me, that the person who’d sooner die than open a blank doc will happily pick a fight with a prompt. Or maybe it was all said already, and the job was never to ask twice but to stand downstream with a net.
I don’t know which is true. I suspect several and can’t tell which. This is the part I keep confessing I’m a third through.
But here’s what I know, and it’s almost funny. It’s the same hole. The exact one. I opened this whole sermon furious that the PRD lied — left the hard part blank, wrote hope in the margin. I built this so the thinking would have a room. And the wall I keep hitting face-first is that you cannot make a person think, or hand the thought over once they’ve had it. The gap just moved. Out of the document, one layer back, into a tired human deciding whether what they know is worth saving — quietly, that word I keep banning, except that’s the whole point: no ceremony, nobody watching, the best thing in the building set down or lost, and not a soul in the room.
I think it’s worth saving. I bet a machine on it. I just can’t bet it for you. That was always the catch.
If you find the way through — and you might, that’s the interesting part.
Tell me.