AI Product Requirements Workflow
Turn a fuzzy business need into requirements a team can build from — interrogate the need into concrete requirements, shape them as user stories, and write the PRD.
The full path to an AI meeting assistant — define the use case, turn transcripts into structured notes, extract decisions and action items, classify follow-ups, write a shareable summary, evaluate accuracy, then ready it for the team.
A meeting assistant earns its place by closing the loop after the call: turning a transcript into notes people read, decisions people remember, and action items with owners that actually get done — not by recording audio or answering customer questions. It isn't a support agent (it faces your team, not customers) and it isn't a research assistant (it works from the meeting's own transcript, not external sources). This project builds that assistant in order: it frames the use case, turns transcript material into structured notes, extracts the decisions and action items with their owners, classifies follow-ups so each is routed to the right place, writes a clean shareable summary, then evaluates summary accuracy and missed actions before readying it for the team. NewPrompt designs the assistant and generates the prompts and resources for each stage; you run those in your own AI tool (ChatGPT, Claude, Gemini) with your own transcripts and own the output. It does not attend meetings, transcribe audio, or run AI on its servers — it gives the build a structure that reliably turns a transcript into acted-on follow-ups instead of a summary nobody reads.
Each stage runs a NewPrompt workflow, with a supporting resource and tool. Work them in order — the output of each stage feeds the next.
See the execution map →Define the meeting assistant use case
Frame what the assistant is for — which meetings, what the notes must capture, and what 'done' looks like — so every later stage serves a defined job instead of a vague 'summarize this'.
Turn the transcript into structured notes
Turn raw transcript material into structured meeting notes — the topics, the discussion, the outcomes — in a consistent shape, so the notes are read instead of skimmed and abandoned.
Extract decisions, action items, and owners
Pull the decisions and the action items out of the discussion, each with its owner and due date, so the meeting produces a tracked to-do list instead of intentions that evaporate.
Classify and route follow-ups
Sort the follow-ups by type and destination — whose queue, which tool, what priority — so each action lands where it gets done instead of in one undifferentiated list.
Write the shareable summary
Write up the meeting as a clean, shareable summary — the decisions, the actions, the open questions — that a teammate who missed the call can absorb in one read.
Evaluate accuracy and missed actions
Check the assistant against meetings with known outcomes — did it capture the decisions, did it miss an action item — so it ships on evidence it's accurate, not on a good-looking demo.
Prepare for team use
Measure whether the assistant actually helps the team — fewer dropped actions, faster catch-up — the success signal, and decide if it's ready before the team relies on it.
An AI meeting assistant designed end to end — structured notes from transcripts, extracted decisions and action items with owners, classified follow-ups, a shareable summary, and an accuracy evaluation — so meetings end with acted-on follow-ups instead of a transcript nobody reopens.
No. This designs the assistant that works from a transcript you already have. NewPrompt generates the prompts and resources; you bring the transcript and run them in your own AI tool. Recording and transcription are separate services.
A support agent faces customers and handles tickets and escalation. This faces your team and turns a meeting's own transcript into notes, decisions, and tracked action items — internal follow-up, not customer support.
A research assistant synthesizes findings from external sources. This works from the meeting's own transcript to produce notes, decisions, and follow-ups — meeting-state synthesis, not external research.
You build it in the order this blueprint runs: frame the use case, turn the transcript into structured notes, extract decisions and action items with owners, classify and route follow-ups, write a shareable summary, then evaluate accuracy before readying it for the team. NewPrompt gives each stage's prompts; you run them in your own AI tool.
You need real meeting transcripts you already have — the raw text of the discussion, not audio. This blueprint starts from that transcript to build structured notes, decisions, and action items; it never records or transcribes. Bring transcripts from meetings with known outcomes too, so the evaluation stage can measure accuracy against them.
Extraction accuracy comes from two stages, not one. Stage three pulls each action item with its owner and due date into a tracked list; stage six checks the assistant against meetings with known outcomes to measure the missed-action rate. You run the prompts and verify the extractions yourself before the team relies on them.
Turn a fuzzy business need into requirements a team can build from — interrogate the need into concrete requirements, shape them as user stories, and write the PRD.
Turn a meeting transcript into notes people actually use — a faithful summary, the action items pulled out and assigned, and a clean shareable format.
Turn messy text into structured data you can trust enough to feed another system — bound the source, extract the fields, force clean JSON, and validate before it flows downstream.
Build a text classification step you can automate on — pull out the unit to classify, assign a label from a fixed set, and validate the label is one you actually allow.
Turn source material and a target audience into clear docs, help, or knowledge-base content — gather the material, outline the piece, write it section by section, then check it for clarity and gaps.
Find out whether an AI agent behaves before users do — define what correct means, build test scenarios with expected outputs, catch failures and hallucinations, then regression-test each version.
Find out whether the thing you shipped actually worked — define the success metric, plan the measurement, classify the real evidence, then render a verdict and an iterate / pivot / scale decision.
Turn a rough feature idea into a structured requirement: problem statement, acceptance criteria, and what's explicitly out of scope.
The board-grade version: strict fidelity, critical quotes preserved, decisions and commitments as the formal record.
Decisions actually made, commitments actually given — extracted from fragmentary meeting notes that never label their action items.
The blocks a reliable classification prompt needs: defined labels, classification rules, edge-case rules, an ambiguity policy, and a confidence contract.
Overview, Key Concepts, How It Works, Usage, Troubleshooting — docs pages with the same shape for every feature, and code in every usage section.
Build the test set an agent has to pass — scenarios across the happy path, edges, and adversarial inputs, each paired with the expected behavior to grade against.
Consolidate the whole validation into one shareable report — the success metric, the evidence, the hit / partial / miss verdict, and the iterate / pivot / scale decision, in a form the team and stakeholders can act on.
Build structured system prompts from role, tone, constraints, and model target.
Build summary prompts with fixed sections, length caps, and no-invention fidelity rules.
Build prompts that extract defined fields from unstructured text — emails, invoices, tickets, résumés.
Build classification prompts that assign labels from a closed set — with label definitions and edge-case rules.
Build prompts that produce documents in a fixed structure — headings, sections, and tables.
Build test generation prompts — unit, integration, or E2E — with framework modes and edge-case coverage rules.
The full path to a content operation that runs, not a pile of posts — set the editorial strategy, research the topics, build a reusable template, then produce and QA structured pieces on repeat.
The full path to an AI research assistant — define its scope, organize the source corpus, ground responses in references, extract key facts, synthesize findings, check groundedness, then validate it for use.
The full path to automation that survives the real world — wire the integrations and triggers, design the control API, move the data through validated stages, evaluate the AI steps, then deploy.
The full path to knowledge that's findable by people and AI — plan the taxonomy, structure it for search, write the articles, tag the metadata, make it retrievable, then ship it maintainable.