Eidos

The PRD that is still true after it ships.

One spec per feature, in the repository beside the code, so your engineers’ agents build from the same file you wrote. Every call made after the sign-off lands on the spec, with who confirmed it and when. For the product manager and the lead engineer on a team that ships with coding agents.

Free for macOS, Windows, and Linux. No account, no subscription.

A feature spec open in Eidos, scrolled to its Out of Scope and Constraints & Decisions sections: two decisions confirmed, one proposed by the AI agent with a Confirm button, and the tasks that serve the spec beside it.
The spec carries its own decisions. The one the agent made waits for a person to confirm it.

Sound familiar?

“We discussed this weeks ago.” “I don’t remember approving that.”

The PRD was approved. Then the requirements kept moving, in meetings, threads, demos, and tickets.

  1. Nobody can say what was agreed

    The decision was made on a call and lives in two people’s memory of a thread. When it comes up again, the meeting is about what was decided, not what to build.

  2. The PRD goes stale the week delivery starts

    Scope changes in the tracker while the document stays as it was signed. Six months on, half of it is out of date, and the new hire cannot tell which half.

  3. The agents never read it

    Your engineers’ agents build from what is in the repository. The PRD lives somewhere else, so it reaches them pasted in pieces, if it reaches them at all.

How it fits

One spec per feature, beside the code.

Install the software framework and every feature gets one markdown file in the repository: why it exists, what it promises, and what it will not do. The work lives in tasks that point at the spec, so the spec describes the product and never fills up with sprint state.

Specs
One per feature, grouped by domain: Intent, Open Questions, Acceptance Criteria, Out of Scope, Constraints & Decisions.
Frames
The product as a whole: architecture, audience, criteria, and market. Every spec is read against them.
Tasks
The work on a board, each pointing at the spec it serves, exported to CSV or Excel when someone asks.
Decisions
Development, Scope, and Meeting calls, each made for a spec and confirmed by a named person.
Comments
Threads on the exact section or criterion they are about, written into the file.
The specs collection as a table, grouped by domain (playback, identity, discovery), with each spec’s summary, status, and type.

What you will use most

The pieces that keep a spec honest after the sign-off.

  • Decisions

    Agreed means confirmed

    Log what a meeting settled as a Meeting decision on the spec. It waits in the inbox until the person who decides confirms it, and keeps their name and the date.

  • Comments

    Questions on the exact line

    A thread starts on the acceptance criterion it questions, follows it through edits, and is closed once it is answered. It is in the file, so a reviewer sees it in the merge request.

  • Backlog

    Work beside the spec

    Tasks on a board, each naming the spec it serves. Close the ticket and the spec stays true, because it never held the ticket’s state.

  • Canvas

    Discovery on a whiteboard

    Sketch the flow with your designer, then promote a sketch into a real spec. It keeps its place on the canvas and opens its file.

  • AI Agent

    The agents read what you wrote

    Claude Code or Codex beside the page with the spec attached. /grill has it ask where the spec is vague before anyone builds from it.

  • Git

    Every change has an author

    A history and a diff for each spec, and a named version for what was approved, without opening a terminal.

Who agreed, and when

The decision is on the spec, not in a thread

Every decision made for a spec is listed in its Constraints & Decisions section, ticked once a person confirms it. A call an agent made on its own arrives as Proposed and stays unconfirmed until someone stands behind it. “I don’t remember approving that” has an answer: the name and the date are in the file.

  • Development, Scope, and Meeting types to start, and your own
  • Assigned to the person who decides, with an inbox and a count
  • Agents log as themselves and never confirm their own
The decisions table: one decision logged by the agent, Claude, still Proposed and assigned to Maya, beside decisions people logged and confirmed.

Nothing changes quietly

A diff for every change to the spec

Open a spec’s File history to see who changed it and when, and the diff of any commit against the spec as it stands. The decisions and the comment threads are part of the file, so they show in the same diff and in the merge request.

A diff of a feature spec in Eidos: a criterion added to Out of Scope, and the spec’s decisions and comment threads added at its foot, each line marked green.

From discovery to a spec

Sketch it first, then make it real

Lay out a flow on a canvas whose cards are your specs, drawn live from their files. When an idea is ready, promote the sketch: it becomes a spec in the collection you pick, and the arrows stay where you drew them.

A canvas of a viewer’s evening in a streaming app, with a sketch about to be promoted into a spec in the specs collection.

For the lead engineer

Set up in the repository, checked on every pull request

Install the framework in the repository, point every agent that reads AGENTS.md at it, and run eidos check in your CI so a pull request that breaks a spec fails (a one-command CI job, eidos ci, comes in the next release). Product managers use the desktop app; nobody has to learn git to write a spec.

$ npm install -g eidosmd
$ eidos install @BuildableWorks/software
$ eidos agents --write
✓ created AGENTS.md with the Eidos nudge
$ eidos check

Start here

Install the software framework.

Frames for the product and specs for the features, with Out of Scope in every template. Pick it in the app when you make a new root in the repository, or install it from a terminal. Then turn on the Backlog and Decisions under Core plugins.

An app, a service, or a system

Software@BuildableWorks/software

Frames for architecture, audience, criteria, and market, and specs grouped by domain.

  • Frames
  • Specs
$ eidos install @BuildableWorks/software

In the app: New Root, then pick it from the list.

See it in the Registry

Put the PRD where the code is.

Download Eidos MD, install the software framework in your repository, and write the spec for the feature your team starts next.

Free for macOS, Windows, and Linux. Your files stay plain text in a folder you own.