PromptWake vs SpecStory

you want the conversation to live in the repo, versioned with the code, with nothing to run and no account required.

you want one record per developer across every AI tool they use, kept out of the repository, with a shared timeline the team can search.

SpecStory is the closest thing to a direct competitor we have, and the comparison is more interesting than most because the disagreement is architectural rather than featural. Both products answer the same question — what did the AI actually build for us, and can we reconstruct why. They put the answer in different places.

SpecStory writes conversations into .specstory/history as markdown inside your project. That is an elegant idea with immediate consequences, all of them intentional. The history is versioned with the code it produced. It travels with a clone. Anyone with repository access can read it in a text editor, with no product involved. If your repository is your system of record, this puts the conversation exactly where the rest of your record already lives.

PromptWake captures the same material out of band: a daemon reads what the AI tools already write to disk, stores it in a local database, and — on the paid tiers — syncs it to a team timeline. Nothing enters the repository, nothing shows up in a diff, and nothing needs to be committed for the record to exist.

Both answers are defensible. The question is whether an AI conversation is a project artefact that belongs in the repo, or an engineering record that belongs to the team.

If you are one developer, or a small team on a single repository, the repo-native approach is hard to beat. There is no service to run, no account to create, and no second place to look. The history is reviewable in a pull request, greppable with the tools you already use, and backed up by the same remote that backs up your code. For an open-source project where the conversation is part of the story, it is arguably the right default.

SpecStory also does something we do not: it derives rules and instructions from your past conversations and feeds them back into the editor. That is a genuinely different product idea — using the history to improve the next session rather than to explain the last one — and if that is the outcome you want, it is the reason to choose them.

• Every conversation is a commit. Chat markdown lands in diffs and pull requests, and reviewers learn to skip it — which is the beginning of it being deleted from .gitignore.
• Prompts contain things repositories should not. People paste stack traces, customer names, tokens and internal URLs into chat without thinking, because chat feels ephemeral. Committing it makes that permanent and public to everyone with repo access.
• It is per repository, not per developer. A developer working across eight repos has eight histories and no single view of their week; a repo with ten contributors has one history with no notion of who did what.
• It only captures where the extension is installed. Editor extensions cover editors — the terminal agents a growing share of work now happens in need their own integration, on every machine, installed by every developer.
• Deleting a repository deletes the record. That is fine for code you no longer want and less fine for the audit trail of how it was built.

None of these are defects in SpecStory. They are the cost side of a trade it makes deliberately, and for a lot of teams the trade is worth it.

Honesty requires the other column. Our history does not travel with a clone: check the repo out on a new machine and the conversations are not in it. There is a daemon to run, which is one more process on the developer's machine. And the free tier is local-only, so a team view means a paid plan — SpecStory's cloud offering starts free.

What you get for that is coverage and separation. The daemon reads the on-disk formats the tools already write, so it captures Claude Code, Cursor, Copilot, Codex, Gemini CLI, OpenCode, Aider and the rest without an extension per editor — including the terminal agents. The record is one timeline per developer rather than one per repository, and it links prompt, response and the resulting file diff so a change can be explained rather than merely found. And because it lives outside the repository, a prompt containing a customer name does not become a permanent line in the history of your codebase.

Ask who needs to read this a year from now. If the answer is 'whoever is working on this repository', put it in the repository — SpecStory is the more direct route to that. If the answer is 'our engineering organisation, across every repo and every tool, including for an audit we have not been asked for yet', that is what PromptWake is built to be.

And if you are not sure, start with whichever is cheaper to reverse. Both keep plain, readable data; neither locks the record inside a format you cannot leave.