What software is worth
The value of software is not its code.
Code is the part you can diff, review and deploy. But anyone who has inherited a system knows how little the code explains. It tells you what the system does. It doesn’t tell you why it works that way, which rules the business insisted on, which edge case cost someone a week, or which obvious simplification would break the month-end close.
That knowledge sits in the heads of the people who build the software and understand the domain it serves. Take the code away from a team that understands its domain and they will rebuild it, probably better. Hand the code to a team that doesn’t, and they will slowly break it. Code is what the team’s understanding produces. The understanding is the asset.
This was always true, and it matters more now. When an agent writes thousands of lines in minutes, code is no longer the scarce part. A team that knows what to build and why, and can tell whether the result is right, is.
So a development process has a different job than getting from idea to code as fast as possible. It has to make sure the team’s understanding is real, shared and written down before the code is generated. Without that, you end up with a large codebase nobody can explain.
Speclr is built on that conviction. The rest of this page follows from it.
Where the spec comes in
Spec-driven development gets one thing right: the spec is the source of truth, and the code is derived from it. We agree, with one clarification about what a spec is.
A spec is the externalized trace of the team’s understanding. That is why it’s useful. People who weren’t in the room can read it. Someone can check whether it’s right. Coding agents can build from it, because they can only build from what is written down. And it survives when someone leaves the team, since the knowledge no longer sits in one head.
Most SDD tools treat the spec as the input to the process: take an idea, generate the document, move on to tasks and code. A generator can produce the record without the understanding behind it, though. The result is a spec that is long, fluent and unread. Nobody discussed it, nobody can review it in depth, and the conversation that should have produced it never happened. Anyone who has been handed pages of generated scenarios to review knows how it goes: the review turns into a skim, and the discussion between the people who should have shaped the spec dies.
A spec is only as good as the understanding it records. Speclr starts with the understanding.
Requirements are found between people
Requirements engineering has always been a human discipline. Requirements come up in conversation. Someone asks a question, someone else realizes they never considered that case, a third person says the rule is different in their department. The spec documents what that conversation produced.
For tools, this means: if the requirements live in more than one head, a tool with one person in it can’t find them. A terminal has one person in it.
Why single-seat tools are the wrong approach
Most SDD tools run inside one developer’s coding agent, on one person’s subscription, with one person’s context. That fits one case well: a solo developer building their own tool, where the requirements live in a single head. There, a terminal is fine.
Everywhere else it breaks down. What the product owner knows, what the domain expert knows and what the customer said in last week’s workshop never reaches the session that writes the spec. The person at the keyboard becomes the bottleneck for everyone else’s knowledge, and each relay loses something. And the AI answers where it should ask. Given a vague idea, a generator fills the gaps with plausible assumptions. A good analyst turns them into open questions for the people who can answer them.
A single-seat tool can produce a spec. It can’t produce shared understanding, and that is the asset.
How Speclr works
Speclr is AI-guided, but you keep control. It doesn’t write the spec for you. It interviews you in complete sentences, the way an experienced analyst would, and it uses established formats instead of inventing new ones: the discovery interview, user story mapping, BDD-style refinement in the spirit of the Three Amigos. The AI supplies questions and structure. The team supplies answers and makes the decisions.
Work moves through four phases. Discovery turns a vague idea into a shared problem and vision. Exploration maps the domain and the user journey. Planning settles scope and quality goals. Refinement turns stories into verifiable scenarios. Each phase ends in artifacts the next one builds on, and export comes last.
What the team learns in one session is available in the next. Domain knowledge carries across phases and sessions, so nobody has to re-explain the product to the tool.
The workspace is multi-user. Product owners, developers and domain experts work on the same artifacts and join the same interviews.
Perspective agents review the work from different angles: consistency, risk, QA, security and architecture. They don’t replace the people in the room. Each one asks what someone in that role would ask.
We also keep the output small on purpose. A few scenarios the team has actually agreed on are worth more than a mountain of generated ones, and a person should be able to read a Speclr spec in full and review it.
A ticket that enters a sprint should be complete and understood. The functional questions are settled before the coding agent starts, so that when the agent stops to ask something during implementation, it’s about how to build, not what to build.
What this is not
It isn’t waterfall. The process runs incrementally. The point is that each increment is understood before it’s built, not that everything is specified up front. It isn’t anti-agile either. What it rejects is the idea that you discover what you want by letting an agent build something and looking at it. It isn’t formal requirements management: Speclr is made for agile product teams, not for organizations that need audit trails and traceability matrices. And it isn’t a chat tool. The conversation is how you get there, and what comes out is structured, reviewable artifacts.
The result
A spec the whole team has talked through, that a developer can review in minutes and a coding agent can build from without guessing. It exports to the tools you already use, so Speclr doesn’t dictate your coding agent. And the team keeps what was worth having all along: an understanding of its own domain, written down.
