Eidos

Software

@BuildableWorks/software

The software seed the standard ships, for a product, service, or system being built; frames for architecture, audience, criteria, and market, and specs grouped by domain.

14installs in the last 30 days23installs in total

Install

The whole project

eidos install @BuildableWorks/software

One collection, or one variant into a collection you already have

eidos install @BuildableWorks/software --collection Frames
eidos install @BuildableWorks/software --variant Frames.audience
Source
BuildableWorks/Eidos on GitHub
Tag
v5.5.1
Path
seeds/software
Eidos version
5.5.0
Naming
kebab-case
Keywords
seedsoftwareproductspecsframes
Published
October 14, 2026

What it contains

Collections

Framesframe

What every other blueprint is judged against: the product's architecture, audience, criteria, and market.

Variants

architecturedefaultthe product as a built system

Template: templates/frame.architecture.md

# {{title}}

_The overarching shape of the product as a built system. When the detail outgrows a single file, expand into an optional `Arch/` folder and keep this doc as the map that points into it._

## Shape

_The system in one breath: the major pieces and how they fit. A paragraph or a simple sketch. Enough that a newcomer can hold the whole in their head before reading any spec._

## Components

_The named parts and what each is responsible for. One line to a short paragraph each. Boundaries matter more than internals here; this is the map, not the territory._

## Data and flow

_What moves through the system and where it lives. The path a request, a record, or an event takes from edge to store and back._

## Boundaries and dependencies

_Where this system ends and others begin. Outside services, platforms, and integrations it leans on. The seams where it could break or be swapped._
audiencewho it serves, and how each kind differs

Template: templates/frame.audience.md

# {{title}}

_Who the product is for, and how each kind of person interacts with it differently. This frame and Criteria are the two that decide scope: a spec that serves no one here, or serves a persona that doesn't exist here, is a spec to question._

## Audience

_Who uses this product, in a paragraph or two. The whole population it is built for, described plainly. Not segmented yet, just the answer to "who is this for."_

## Personas

_How each kind of person interacts differently. One short block of prose per persona, never a table or a headshot-and-demographics card. The point is the difference: what this persona comes for, how they reach for the product, what they ignore. A persona earns its place here only when it interacts in a way the others do not._

### Persona name

_What this person is here to do and how they go about it._

### Persona name

_The next persona, described by how it differs from the one above._
criteriabudget, scope objectives, timeline

Template: templates/frame.criteria.md

# {{title}}

_The frame that decides and audits scope: what the product can afford, what it is trying to be, and by when. When scope creeps, it creeps past this doc._

## Budget

_How the work gets financed and what that buys. The rough money or resource envelope: funded how, spending against what, for how long the runway lasts. Enough to tell whether a given spec is affordable._

## Scope Objectives

_What the product is aiming to be at this level: a prototype, an MVP, a production product, a platform. The objective sets the ceiling on scope. State it plainly so specs can be checked against it._

## Timeline

_The limits time imposes. Hard dates, milestones, or seasons that bound the work. What must exist by when, and what that forces to wait._

## Parameters & Variables

_The large-scale factors that move scope — the things that, if they change, change what is feasible or sensible to build. An integration going live, a development partner coming on or dropping off, a funding milestone, a platform deadline, a key hire. Name each one and what it would change._
marketlandscape, positioning, and how it earns

Template: templates/frame.market.md

# {{title}}

_Where the product sits in its marketplace, why it is not just another one of many, and how it is intended to make money._

## Landscape

_The market this product enters: the category it lives in, and the substitutes people reach for today. An honest picture of how crowded it is._

## Competitors

_The specific products and alternatives you are up against — named. For each, a line on what it does well and where it leaves a gap. Include the "do nothing" or "use a spreadsheet" substitutes, not just the direct rivals._

## Positioning & Differentiators

_Where this product sits, and the specific thing that makes it not interchangeable with the rest. Not a slogan: the concrete difference a user would feel. If you cannot name it, that is the most important thing this doc has surfaced._

## Who it is for and against

_The slice of the market this product wins, and the competitors it wins it from. The customer it serves better than anyone, stated plainly._

## Earning Capabilities

_How the product is intended to make money. The revenue model: what is charged, to whom, on what cadence. Where the money comes from, and what has to be true for it to work._

Specsspec

The product's units, one per blueprint, grouped by domain.

Grouped by Domains

Variants

fulldefaultthe complete spec template

Template: templates/spec.full.md

# {{title}}

## Intent

_Why this exists: the problem, who has it, and what this unit is for. One or two paragraphs that stand on their own; a reader who opens only this spec learns what it is without following a link. This is the stable part: if Intent changes substantially, you probably have a different spec, not an edit to this one._

### Assumptions

_What you take as given about the problem or the world and have not confirmed. Nested under Intent because they frame it. Surface them so a guess doesn't slip into the requirements as if it were settled._

## Open Questions

_What is still unknown and needs an answer. Kept high, right after Intent, so uncertainty is seen rather than buried. When one is settled it leaves this section and becomes an Assumption, a Requirement, or a Decision; delete the section when none is open._

## Requirements

_What it does, as observable outcomes: if it isn't listed here, it isn't promised. Label each **REQ1:**, **REQ2:**, … (bold), starting at 1 in every spec and running in order with no gaps. Group them under the categories that apply as `###` sub-headings (Functional, Performance, Design, External interface, Quality attributes), the numbers running on across them. Keep each short and checkable; push rich detail into a table or sub-section it points to. Link to another spec's requirement by its label: `[Sign In REQ6](../identity/sign-in.md#req6)`._

### Functional

- **REQ1:** <!-- features, behaviors, business rules -->

### Performance

- **REQ2:** <!-- speed, throughput, response time, capacity, concurrent users -->

### Design

- **REQ3:** <!-- mandated tech, standards, regulatory rules, platform limits -->

### External interface

- **REQ4:** <!-- how it connects to users, hardware, other software, networks: UI, APIs, protocols -->

### Quality attributes

- **REQ5:** <!-- the other -ilities: reliability, security, usability, maintainability, scalability, portability -->

## Out of Scope

_What a reader might expect this spec to cover and it does not, each named and, where another spec holds it, linked there. This is where scope is held: name the neighbouring concerns one by one rather than pointing at a whole spec._

## Dependencies

_What this relies on to work, and what for: services, libraries, data, or other specs, each linked (`[Session Management](../identity/session-management.md)`). A relationship, never an order of work. The `depends_on` property is the spec-only subset of this, as links._

## Decisions

_The calls that shaped this spec and why, one line each, newest last, with the date and who made it. Append-only: a reversal is a new line, never an edit to the old one._

<!-- 2026-06-17: Dropped the SMS fallback, carrier cost. (Brenton) -->
microIntent, Open Questions, Requirements, Out of Scope; grow into full

Template: templates/spec.micro.md

# {{title}}

## Intent

_Why this exists: the problem, who has it, and what this unit is for. One or two paragraphs that stand on their own. This is the stable part: if Intent changes substantially, you probably have a different spec, not an edit to this one._

### Assumptions

_What you take as given and have not confirmed. Nested under Intent because they frame it. A micro spec almost always has some; surfacing them is half the point of writing one early._

## Open Questions

_What is still unknown and needs an answer. When one is settled it leaves this section and becomes an Assumption, a Requirement, or a Decision; delete the section when none is open._

## Requirements

_What it does, as observable outcomes: if it isn't listed here, it isn't promised. Label each **REQ1:**, **REQ2:**, … (bold), starting at 1 and running in order with no gaps. Keep each short and checkable._

- **REQ1:** <!-- the first observable outcome -->

## Out of Scope

_What a reader might expect this spec to cover and it does not, each named and, where another spec holds it, linked there._

Other folders

  • assets Images, diagrams, and documents the blueprints link to.

Roles

Designerroles/designer.md
# Designer

## Who they are

Shapes the experience and who it's for. Owns flows, states, and audience — not architecture or the data model.

## How to respond

- **Vocabulary & depth:** UX and product terms. **Translate technical constraints into experience terms** — avoid db relationships, indexes, query plans, and deploy mechanics unless they ask. A designer shouldn't have to parse "composite key" to understand "the list won't show duplicates."
- **Decisions:** contribute to Audience, the requirements, and the external interface; defer architecture and data-model calls to the owners and the Developer.
- **Surface / hide:** surface what the user sees and feels — flows, states, the empty and error cases; fold the how into a link, not the reply.
- **Focus:** Audience, the user-visible requirements, the external interface, and the states a screen can be in.

## Calibration

**Technical capacity** is low by default for this role; raise it if the designer is comfortable with the stack, and they'll get more mechanism.
Developerroles/developer.md
# Developer

## Who they are

Builds the product from its blueprints. Reads a blueprint to answer "what am I building, exactly?" and to find the edges, the dependencies, and the things still undecided.

## How to respond

- **Vocabulary & depth:** technical depth is welcome — data models, indexes, relationships, dependencies, edge cases, failure modes. Be precise.
- **Decisions:** clarify and flag, don't decide. Product calls — scope, direction, priorities — belong to the owners; surface ambiguity and missing decisions rather than resolving them.
- **Surface / hide:** surface Requirements, Dependencies, Out of Scope, Decisions, and anything underspecified that would block a build.
- **Focus:** what's promised vs. what's vague; the REQ labels; what each spec depends on.

## Calibration

**Experience with the scope** sets how much orientation to give; **technical capacity** is high by default for this role, but honored if calibrated down.
Project Managerroles/project-manager.md
# Project Manager

## Who they are

Tracks **scope and progress**, not product direction or implementation. Wants to know what's in and out of scope, how far along each unit is, where the dependencies and risks are, and roughly what's left — and to keep that picture current as the blueprints change.

## How to respond

- **Vocabulary & depth:** scope, status, dependencies, risk, and effort — in plain terms. Skip deep implementation and product rationale unless it bears on scope or schedule.
- **Decisions:** none are theirs. They don't set direction (the owners) or make technical calls (the Developer); they surface scope creep, blocked or at-risk units, and gaps, and bring them to whoever owns the call.
- **Surface / hide:** surface **Out of Scope** (the in/out line), each unit's `status` (its lifecycle stage), `depends_on` and other dependencies, and the Decisions log with the `created`/`modified` dates that show movement. Fold away mechanism and prose rationale.
- **Focus:** what's in vs. out, what stage each unit is at, what blocks what, and where scope is drifting from Criteria.

Remember Eidos captures **state and intent, not work** — there are no sprint, estimate, or assignee fields, on purpose. So for this role: read **progress** from `status` and git history (the Decisions log, `created`/`modified`), not a burn-down; infer **level of effort** from a unit's shape — its acceptance criteria, dependencies, and open questions — not a stored estimate; and for sprint-level tracking, point to the tracker a unit links to rather than adding work fields to a blueprint.

## Calibration

Usually moderate **technical capacity**, and broad-but-shallow **experience with the scope** — they span the whole product rather than living in one unit. Lean on `status`, dependencies, and the in/out line.
Stakeholderroles/stakeholder.md
# Stakeholder

## Who they are

Reviews direction and outcomes — a sponsor, a partner, a lead from another team. Cares about where the product is going and what it costs, not how it's built.

## How to respond

- **Vocabulary & depth:** plain, outcome-oriented language. No implementation detail unless asked; translate everything into impact, scope, and risk.
- **Decisions:** advisory. They weigh in on direction; the owners hold the call. Don't ask them to make build decisions.
- **Surface / hide:** surface summaries, scope, trade-offs, and risk; hide mechanism entirely.
- **Focus:** Market, Criteria, and the shape of scope — what's in, what's out, what it costs.

## Calibration

Usually low **technical capacity** and partial **experience with the scope** — lean on summary and framing.

Top-level documents

  • README README.md the root's front door: what this is, and pointers in.

Custom properties

statusTextevery collectionLifecycle stage. (Draft | Intake | In Progress | Done | Archived | Deprecated)
date_createdDateevery collectionYYYY-MM-DD. Set once.
date_modifiedDateevery collectionYYYY-MM-DD. The last change.
tagsListevery collectionFree tags.
domainrequiredTextSpecsThe group: matches the blueprint's sub-folder. An unknown value warns.
depends_onListSpecsBlueprints this one needs, each a markdown link.
typeTextSpecsSoft category label: drives views and filtering, never structure. e.g. feature, capability, integration.

README

The first top-level document, as the author wrote it at this tag, placeholders included. Links open the source.

{{Product}}

Start here. This is the root for {{Product}} — the source of truth for what the product is, true whether or not it’s been built.

This README is the front door. The full index and config live in .eidos/Framework.yaml; this file orients you and points the way.

What this is

One or two sentences: what {{Product}} is, and for whom.

Top-level documents

Your own one-of-a-kind docs: a Vision, a set of Design Principles, the generated Blueprint Map. Add them here as you write them.

Folders

  • Frames — the framing docs: Architecture, Audience, Criteria, Market.
  • Specs — the product’s units, grouped by domain.
  • assets — images, diagrams, and documents the blueprints link to.

A root. Its framework lives in .eidos/; see .eidos/Framework.yaml for the full index. eidos index keeps the index current.