The product

PRDs

A PRD is how a mapped feature becomes a plan your agent can build from. This page explains what PRDs are, the node that writes them, why there is a front end and a back end version, and how they sit inside your mind map.

What a PRD is

PRD stands for product requirements document. It is a short write up of one feature: what it is, how it should behave, and how it connects to the rest of your app. In CodeSpring a PRD is written for your coding agent to read, not for a team meeting, so the agent builds from a clear brief instead of filling the gaps with guesses.

You do not write a PRD from a blank page. CodeSpring generates it from the feature you already mapped, using the notes and context around it. The map does the thinking, the PRD writes it down.

The PRD Bridge node

The PRD Bridge, marked with purple tabs on the canvas, is the node that turns a feature into a plan. Reach for it once a feature is mapped and you are ready to generate the plan the agent will follow.

PRD

Generate PRD

Get Started Creating Your PRD

Select the type of Product Requirements Document you'd like to generate

Frontend / UI

Generate requirements for user interface and frontend features

Backend Features

Generate requirements for backend logic and API endpoints

Database Design

Generate requirements for database schema and data models

The PRD Bridge lets you pick which plan to generate: frontend, backend or database.

For where the PRD Bridge sits among the other node types, see Nodes explained.

Front end and back end

The PRD Bridge writes your front end and back end PRDs together, so the two sides never drift apart. Each one covers a different half of the same feature.

Frontend PRD

Task Dashboard

The dashboard is the first screen a signed in user sees. It shows their active projects and a summary of what needs attention.

Layout

A left rail lists every project the user owns.
The main panel shows a grid of task cards for the selected project.
A top bar holds search, filters, and the new task button.

Components

Project card shows the title, task count, and a colored status dot.
Task card shows the title, assignee, due date, and a priority pill.
Empty state appears when a project has no tasks yet.

Behavior

Selecting a project loads its tasks in place, with no full reload.
Creating a task opens a side panel and adds the card on save.
Moving a card between columns updates its status instantly.

Frontend PRD: the screens a user sees and how the interface looks and behaves.

Backend PRD

Overview

This service exposes the REST API and background jobs that power the project workspace. It handles authentication, persistence, and the sync layer between the editor and the live preview.

Core Responsibilities

Auth session issuing, refresh, and organization scoping
Projects create, read, update, share, and version history
Sync websocket fan-out for multiplayer edits

API Endpoints

POST /api/projects create a new project
GET /api/projects/:id fetch a project with its nodes
PUT /api/prds/:id update PRD content and name

Data Model

Project
  id          uuid  pk
  org_id      uuid  fk
  name        text
  created_at  timestamptz

Non-functional

p95 request latency under 200ms
Horizontal scaling behind the load balancer
Structured logging with request tracing

Backend PRD: the logic behind the screens and the data it reads and writes.

Generating them from one place is what keeps them consistent. The button on the screen and the logic behind it are described against the same plan, so the agent does not build one to fit an idea of the other.

Inside the mind map

PRDs are not a separate document you keep somewhere else. They live inside the mind map, attached to the feature they describe, joined by the same visible edges as everything else. Because the plan sits next to the feature, you can see at a glance which parts of your app have a plan and which do not.

New to the canvas and how nodes connect? Read The mind map first.

Hand it to your agent

Once a feature has its PRDs, your agent can read them and build. You install the Getting started skill so the agent knows how to find your plan, then you can tell it something as simple as read the CodeSpring plan and build the next feature. The map stays the source of truth, so you never re-explain the app from memory.

The plan is portable. The same PRDs work whether you build with Claude Code, Codex or Cursor. For the full handoff, see Connect your agent.