The short answer

Write each feature as a short list of behaviours you could observe from outside the code, have the feature's owner approve it, and check every agent change against that list. TestSprite does the heavy lifting: give it plain words, PRDs or tickets, and it drafts a test plan for your approval, then runs it against your app on every change.

Any starting point

A PRD, Jira or Linear tickets, or a few plain sentences. No document required.

Approved by you

Every test states its expectation in plain language; you read, edit and approve the plan.

Checked on every change

The approved plan becomes an end-to-end suite that runs on each pull request.

Why written intent is now your most valuable spec

For years, much of what a product should do lived with the engineers who built it: annual plans bill up front, viewers can't export, a deleted project stays recoverable for a while. Code review worked partly because reviewers carried the same memory.

Coding agents start each session with your request and whatever files they read. Tests generated from today's code encode today's behaviour, bugs included. A written record of intent, from the user's point of view and approved by the people who own it, is the reference that stays stable. It does two jobs at once: agents build from it, and a verifier checks every change against it.

Instruction files say how to build. A feature map says what to build.

Keep your CLAUDE.md or AGENTS.md; it makes every session better. It just answers a different question:

CLAUDE.md / AGENTS.mdFeature map
HoldsConventions, commands, architecture rulesWhat each feature must do, from the user's view
Read byThe coding agentPeople, coding agents and the verifier
Enforced byThe agent's best effortAn end-to-end test on every pull request

Lauren Tan's "trust pyramid" puts written rules for agents at the light top layer, above code-level constraints and runtime verification. A feature map is what lets the verification layer do its job.

The feature map: a few lines per feature

In her talk "All Code Is Slop (Except Mine)" at the AI Engineer Code Summit, Lauren Tan described the verification setup behind a team merging about 11,000 pull requests a month. One of its pieces was a feature map: every feature in the product, described from the user's point of view, which gave runtime verification something to verify against.

You can start one today. A feature map is a list of features, each with its expected behaviours written as things you could observe from outside the code.

A feature map template

Here is one entry, in a format that serves people, coding agents and tests alike:

Feature: Invite a teammate
Who: workspace owners and admins

Expected:
- An admin enters an email and a role; the invite appears under Pending.
- The invitee receives an email with a link. After signing up through it,
  they land in this workspace with the role they were given.
- A member who is not an admin does not see the Invite button.
- Inviting someone who is already a member shows "Already in workspace"
  and sends no email.

Rules:
- An invite link works once.

Not decided:
- Whether invites expire.

Five habits make entries like this work hard for you:

  • Observable, not internal. Describe what a person or client sees: a screen, a message, an email, an API response. "The invite appears under Pending" is checkable; "calls the invite service" is implementation.

  • One behaviour per line, so a failing check points straight at one broken promise.

  • Include what must not happen. Permission and money rules are mostly negatives, and they are the expensive ones to break.

  • Mark what isn't decided. A clear "not decided" keeps a coding agent from inventing a rule and a test from enforcing one.

  • Focus on what matters. Exact copy, colours and spacing usually belong to design review.

Where the entries come from

Most teams have more intent written down than they realise; it is just scattered. Each source has a strength and a trap:

SourceWhat it gives youWatch for
PRDs and specsIntended flows and rules, often with edge casesSections never built, or changed after launch
Jira or Linear ticketsPrecise acceptance criteria for each changeSpread across many tickets; later ones override earlier ones
Plain words from the feature ownerThe fastest source, and the only one with the unwritten rulesBenefits from a second reader before it becomes the bar
Support tickets and incident notesWhat customers actually rely onWritten as complaints; turn each into an expected behaviour
DesignsScreens, states and empty statesShow layout more than rules
The running appA quick inventory of features to describeIncludes today's bugs, so use it to find features, not as the bar

No PRD? Start here

Plenty of great products have no PRD, especially ones built quickly with coding agents. Skip the retroactive document and build the map from the outside in:

  1. List what customers pay you for. Five to ten features is plenty to start: sign-up and sign-in, the core workflow, billing, sharing, settings.

  2. For each, write what a customer does and what they should see, in the plain sentences you would use with a new hire.

  3. Add the "must not" lines for permissions and money.

  4. Add your last few incidents as expected behaviours, so those bugs stay fixed.

  5. Have each feature's owner approve it. Approval turns notes into the bar.

  6. Grow it with every ticket. Each change that alters behaviour updates its entry.

With TestSprite, steps two through five can start as a conversation: describe the flows in your own words, and it drafts the plan for you to approve.

Keep the map in sync

Three habits keep the map current. Every ticket that changes behaviour names the entry it changes, approved by the feature owner. Agent pull requests link the entries they touch, so reviewers know what to check. And when the app and the map disagree, a person decides which is right: either the app has a bug, or the map needs an approved update. Keeping that decision with people is the heart of independent verification.

That is where the map pays off. A regression suite built from it catches the breaks agents cause in flows nobody mentioned, as the regression testing guide explains.

How TestSprite turns intent into checks

TestSprite works from exactly this kind of record, and it doesn't need it to be tidy. Tell it what your product should do in plain words, or point it at your PRD, your Jira or Linear tickets, or your repo to make it sharper. It drafts a test plan in your workspace in which every test states what it expects in plain language. You read it, edit it and approve it, and when something is unclear it asks you there instead of guessing. That approved plan is what every later change is checked against.

The approved plan becomes an executable feature map. TestSprite writes the end-to-end tests from it, frontend and backend, runs them against the running app on every change, and keeps them current as the interface changes. What a test expects only changes when you approve it. QA, or whoever owns quality on your team, stays the owner of what "correct" means, and nobody needs to write code to take part.

Frequently asked questions

Is this the same as a PRD the coding agent builds from?

Same source, two uses. The entry you write so an agent builds the right thing is the entry a verifier checks the result against. Writing it once in observable terms serves both.

How detailed should entries be?

Detailed enough that two people would agree whether the app meets them. "Checkout works" is too vague; "the receipt shows the total including tax" can be checked.

What if the app already contradicts the PRD?

A person decides which one is right: file the bug, or update the entry with approval. Either way the decision is explicit and recorded.

Can TestSprite work with no documents at all?

Yes. Plain words are enough. Describe the flows that matter; TestSprite drafts a plan, asks about anything unclear, and you approve it.

Who owns the feature map on a large team?

Each feature's owner, usually a product manager or the QA lead for that area, approves its entries. Engineers and coding agents propose changes; owners approve them.

Try TestSprite

Define "correct" once. Check every change against it.

Coding agents need a record of intent that outlives the session, and so does your test suite. TestSprite turns your plain words, PRDs and tickets into an approved test plan, then checks every change against it in the running app. Start free with the flows your customers pay for.