Chapter 13: Meeting Recording→PRD→TDD→Code: AI-Native Team's Knowledge Workflow

"One of the more radical ideas from earlier drafts, worth trying once we have the money and the people: record every meeting → generate transcripts → generate PRDs → generate TDDs → generate code drafts."

Further reading: for how this pipeline fits into the broader AI-native workflow loops, see AI-Native Workflows: Plan/Act, Test/Code, Doc/Code/Doc. For why small teams are unusually well positioned for this approach, see The Structural Advantages of AI-Native Small Teams. For how user stories plug into this pipeline, see Five Levels of AI Coding and the User Story Driven Endgame.

1. A "radical" but workable vision

The May 2025 revision sketched out a complete knowledge workflow pipeline:

1. Meeting recording → generate subtitles/transcript
2. Transcript → generate PRD
3. PRD → generate TDD (technical design document)
4. TDD → generate code draft
5. Code draft → human review and refinement

Fully built out, it looks like this:

"Use browser-use as the middleman to forward all internal knowledge, codebase included, to Gemini Web, and use that to raise productivity across every kind of internal work. Combine it with newer tools like Flowith and Manus. This internal work platform becomes the primary workspace for every role and every team member."

2. Why this pipeline matters most for small teams

A new, small team carries little historical debt. There are no legacy systems or accumulated baggage in the way, so it can pull all of its knowledge onto one platform quickly. It can also put AI into every step of how it works: a big company might manage to modernize 10 steps, while a small team can run AI through all 100, and the compounded efficiency ends up far ahead of the big company. Small-team knowledge is also denser and more concentrated, which makes it easier for AI to ingest and process in full.

The core value of the pipeline is turning unstructured knowledge into structured assets. Meeting recordings, discussions, design sketches, all the knowledge that used to be scattered everywhere, can now be converted automatically into part of the codebase. Less information gets lost along the way. Decisions, debates, and design reasoning from a meeting used to survive only in the memory of whoever attended; now all of it gets captured, where AI can draw on it for later development and maintenance. It also makes knowledge work itself something you can automate. AI stops being just a code generator: understanding requirements, designing the system, and writing the docs can all have it in the loop.

3. Technical implementation path

The core toolchain:

1. Meeting recording and transcription

   • Use the automatic transcription built into existing meeting tools (Zoom, Tencent Meeting, and the like)
   • Or use a dedicated transcription service

2. Browser Use as the middleman

   • Browser Use lets AI reach internal systems, the codebase, and document stores
   • It forwards the transcript, the codebase, and related docs to Gemini Web together

3. Gemini Web as the knowledge processing hub

   • A 1 million token context window can hold an entire project's knowledge at once
   • The AI can then see how the meeting discussion relates to the existing codebase and docs

4. Flowith, Manus, and similar tools as workflow orchestrators

   • They automate the pipeline: transcript → PRD → TDD → code
   • Every stage can have a checkpoint where a human reviews and signs off

4. Another use case: batch-generating operations content

Beyond the meeting → code pipeline, there is a second practical use case:

"Use a generic MCP to integrate tools like Manus and Flowith. Say the ops team needs 100 pieces of scenario content: an agent completes the whole job, a human signs off, and the content gets imported into our platform. This agent becomes the homepage of everyone's browser, the entry point where all work starts."

This is AI taking on repetitive, high-volume work. Writing 100 pieces of scenario content by hand would wear anyone out, but an AI can generate them as a batch, and the human's job shrinks to confirmation and quality gating. Once a piece passes review, it goes straight into use. The same agent can also become the front door for work in general: anything that involves generating content in bulk, not just code, can run through it.

5. Challenges and limits

The main challenges:

1. Quality control

   • AI-generated PRDs, TDDs, and code vary in quality
   • A human has to review seriously at every stage; running it fully automatic is not an option

2. Information accuracy

   • Meeting transcripts contain errors
   • The transcript → PRD step can drop critical information
   • Someone has to verify the accuracy of each stage's output

3. Context management

   • Past roughly 10M tokens of project scale, even Gemini Web can no longer load everything at once
   • That calls for smarter context selection strategies

For actually landing this, start small. Try the pipeline on one small project with one small team and build up experience. Keep a human checkpoint at every stage rather than letting anything run end to end unattended; every generated artifact needs a human sign-off. And revisit the design regularly: if one stage keeps producing problems, change the pipeline instead of pushing through.

6. Where this pipeline goes

Today this pipeline still sits in the "radical imagination" column, but as AI capabilities improve it could become standard kit for AI-native teams. The meeting ends and the PRD is already drafted; you review and refine it. The TDD comes out of the PRD, and your job is to sanity-check the technical approach. The code draft comes out of the TDD, and you review and test. Knowledge that used to be scattered across recordings and chat threads becomes part of the codebase: searchable, understandable, reusable, available to AI whenever it is needed.

7. Wrapping up

Meeting recording → PRD → TDD → code. The full pipeline is still a radical sketch, but it points at one possible future for AI-native teams:

AI can take part in, and accelerate, every kind of knowledge work.
Humans stop organizing requirements by hand, writing docs by hand, and writing code by hand. AI takes the first pass, and humans review and refine.

For small and new teams, the pipeline is especially attractive:

• Little historical debt, so it can land quickly
• Every step can run through AI, so the efficiency gains are hard to miss
• Knowledge is dense enough for AI to understand and process in full

For now it stays in the "try it once we have the money and the people" stage. But as models get better and the toolchain matures, this pipeline may well end up as the default setup for AI-native teams.