You have the feature clear in your head. You can see exactly how the signup flow should work, what happens when a card declines, what the empty state says. Then you sit down to write the spec, and three hours later you have a half-finished Google Doc, two contradictory bullet lists, and a Slack thread with your contractor that starts with "wait, so what happens if…"

By the time you've answered all the "what happens if" questions, the contractor has already built the wrong thing. Unclear requirements are one of the most cited reasons software projects slip or fail — the Project Management Institute has repeatedly flagged poor requirements and changing scope as top causes of project failure. And when you're a solo founder or a two-person team, there's no product manager to catch the gaps. The gaps are yours.

The usual advice is "use a good PRD template." But a template is a blank form. It tells you which boxes exist; it doesn't fill them. You still have to think of every edge case, write every acceptance criterion, and draw every flow. That's the actual work, and it's the part you don't have time for.

You don't write the spec. You describe the feature.

Here's the shift. The old way to make a spec was to open a blank template and grind. The new way is to tell Dotallio's AI chat what you're building in plain language and let it assemble the whole spec for you — the requirements doc, the feature tracker, the flow diagram, the acceptance-criteria table — as editable, version-controlled artifacts.

You don't build it. You describe it, and Dotallio assembles it. Then it keeps it alive as the feature evolves: you edit any version, roll back a bad change, and refine by chatting instead of rewriting.

Dot — the friendly blue dot in the corner — is the thing turning your half-formed idea into a structured spec a developer can actually build from.

A real session: from one sentence to a full spec

Open a chat in Dotallio and start with the messy version of your idea. You don't need to clean it up first.

Write a product spec for a "magic link" passwordless login. Users enter their email, get a one-time link, and click it to sign in. Cover the happy path, edge cases, validation rules, and error states. Output it as a doc.

Dotallio produces a doc artifact with real structure: overview, user stories, the happy-path flow, and — this is the part you'd have forgotten — the edge cases. Expired link. Link already used. Email typo'd so it never arrives. Same link clicked on two devices. Rate-limiting so nobody can spam someone's inbox. Each one written as a condition → expected behavior pair, not a vague note.

That doc is editable and versioned. Don't like how it handled rate limiting? Tell it so, and it revises in place while keeping the old version available to roll back to.

Now turn the prose into something you can track against:

Turn the requirements in this doc into a board where each requirement is a row, with columns for priority, type (functional / UX / technical / edge case), acceptance criteria, status, and dependencies. Pre-fill the rows from the spec.

You get a board — every requirement is a row with the right column types, populated from the doc you just made. Now your spec isn't a wall of text; it's a tracker your contractor can work down line by line, marking each one done.

Need the flow on one page so nobody misreads it?

Make a flowchart of the magic-link login flow, from "enter email" through link click, including the expired-link and already-used branches.

Dotallio generates a chart artifact (a Mermaid flowchart) showing every branch — including the error paths most specs leave implied. Your developer sees the decision tree instead of reconstructing it from paragraphs.

And when the spec needs to point at a system that already exists, pull it in with an @-mention:

Add a "Technical notes" section. @board:auth-data-model — make sure the magic-link tokens fit the existing users and sessions tables, and call out any new fields we need.

The @-mention pulls your existing data model into the chat as context, so the technical section references your real schema instead of a generic one.

Keeping the spec alive after the kickoff

A spec isn't done when you hand it over — it changes the moment someone asks a question or a requirement shifts. This is where most documents rot. In Dotallio, the spec stays current because the AI keeps working on it.

AI-filled columns. Your requirements board has an empty "acceptance criteria" column? Tell Dotallio to fill it for every row in bulk. It writes a testable criterion per requirement — "Given an expired link, when the user clicks it, then they see 'This link has expired' and an option to request a new one" — across the whole board at once, instead of you typing thirty of them by hand.

Web research and enrichment. At the higher "smart" levels, the AI plans multi-step work and runs live web research. Ask it to check how comparable products handle session expiry or what the common security pitfalls are for magic-link auth, and it researches, then enriches your rows with what it finds — sourced, not invented.

Triggered workflows. You can wire a Smart Workflow to run on demand, from a button, on a board event, or from an incoming webhook. Mark a requirement "Ready for spec review" and have a workflow fan out the sub-tasks, draft the test cases, and route it for sign-off. (These run when you trigger them or when an event fires — not as unattended jobs ticking away while you sleep.)

Versioned artifacts. Every doc, board, chart, and table the chat makes is version-controlled. When scope changes in week three, you don't start a new "v2 spec FINAL" file. You edit the live artifact, the old versions stay accessible, and you set visibility to private, your whole workspace, or a public link you can hand a freelancer.

What this looks like in real life

You're a solo founder building a scheduling tool. A beta user reports that double-bookings slip through when two people grab the same slot at the same instant. You need a spec for proper slot-locking, and you need it before your contractor starts Monday.

Friday night, you open a chat:

Spec out a slot-locking mechanism so two users can't book the same time slot simultaneously. Cover the race condition, what each user sees when they lose the race, timeout/release behavior, and how it interacts with @board:bookings-schema. Make a doc, a requirements board, and a sequence diagram.

You get all three: a doc that names the race condition and the resolution, a board of trackable requirements with acceptance criteria, and a sequence diagram showing the two-user timing. You read it, tweak the timeout from 30 seconds to 60 by asking the chat, and share the public link with your contractor. Monday morning they build the right thing the first time — no "wait, what happens if both click at once," because that's literally requirement #4, with its own test case.

The whole thing took you twenty minutes on a Friday instead of two days and four clarifying calls.

Why this beats a blank template

• You describe, it assembles. One plain-language prompt produces the doc, the board, and the diagram — not an empty form you fill alone.
• The edge cases come to you. Dotallio surfaces the expired-link, double-click, and race-condition cases you'd discover later in production.
• Prose, tracker, and diagram stay in sync. Generate a requirements board and a flowchart from the same spec, so words and visuals match.
• Acceptance criteria in bulk. AI fills testable criteria across every requirement at once instead of you typing them row by row.
• Grounded in your real systems. @-mention an existing board to anchor technical notes to your actual schema.
• It stays alive. Versioned artifacts, AI columns, web research, and triggered workflows keep the spec current as scope shifts — with rollback when a change goes wrong.

Start with the messy version of your idea

You don't need a product team, a PRD template, or a clean head before you write. You need to describe the feature once and let Dotallio turn it into a spec your developer can build from — and keep refining it by chatting as the work moves.

Open a chat, paste your roughest notes, and ask for the spec. Try Dotallio Free.