Skip to main content
From Rob, Mostly

The Output of a Business Meeting in 2026 Is a Prompt, Not Notes

8 min read

The Output of a Business Meeting in 2026 Is a Prompt, Not Notes

Meetings stopped being the work a long time ago. The translation was.

TL;DR — For decades, the default output of a meeting was notes, action items, and a Slack thread. In 2026, the highest-leverage teams replace all of that with one artifact: a structured prompt — a spec written for machines first, humans second — that flows directly into a coding agent, research harness, or workflow engine. The meeting becomes the ingestion layer; the prompt becomes the unit of execution. This isn't a new idea — it's PRDs, RFCs, and acceptance criteria, finally reaching the audience they were always written for.

The thing everyone is quietly doing

A friend runs a 40-person fintech. Two months ago she stopped sending meeting recaps. Now her ops lead ends each call by pasting a Markdown block into a shared repo. Engineering picks it up; an agent drafts the first pass; a human reviews before anything ships.

Cycle time on internal tooling, she says, went from "next sprint" to "before lunch."

She isn't doing anything novel. She's doing what good PMs have always done — write a tight spec — except the reader changed. The reader is now an agent that will start work in the next sixty seconds, not a human who will read it on Tuesday.

That small change in audience changes everything downstream.

What we used to do, and why it worked

For most of the last two decades, the output of a meeting was a human artifact: notes, action items, a follow-up. That worked because every downstream step also required a human — to interpret, translate, ticket, spec, delegate, clarify, implement. The meeting was the start of the human translation pipeline.

The bottleneck was never the meeting. It was the translation.

Agents collapse the translation step. If the artifact can be read directly by the thing that does the work, the cost of producing a structured artifact in the meeting (a little) is dwarfed by the cost of not producing one afterward (a lot).

"But isn't this just a PRD?"

Mostly, yes. The format owes everything to PRDs, RFCs, design docs, and well-written Jira tickets. The discipline isn't new. Three things are:

  1. The reader is an agent first. Which means it must be self-contained — no implicit context, no "ask Sarah," no "you know what I mean." Agents don't fill gaps charitably.
  2. The latency target is minutes, not weeks. A PRD that takes three drafts to get right is a PRD that never gets written by a busy team. A prompt artifact has to be cheap enough to produce in the last five minutes of a meeting.
  3. It executes, then gets reviewed — not the other way around. A PRD is read, debated, approved, then executed. A prompt artifact is executed cheaply, the output is reviewed, and revision happens against running code or a real draft.

If you've ever watched a 20-page PRD rot in Confluence, you already know what kills these artifacts. The next section is about not doing that again.

Why this won't rot the way PRDs rotted

PRDs rotted because (a) they were written for an audience that wouldn't read them, (b) they had no owner after handoff, and (c) they were stored where no one looked.

Prompt artifacts survive when you treat them as code:

  • Live in the repo, next to the thing they produce. Not in Notion. Not in Confluence.
  • Version-controlled. Every revision is a diff against a real outcome.
  • Single owner, named at the bottom of the artifact, who signs off on what ships.
  • Short half-life. A prompt artifact's job is to compile into execution this week. If it's still sitting there in a month, archive it.

The artifact isn't documentation. It's the input tape for a specific run.

Notes vs. prompt artifact

A traditional recap looks like this:

Discussed onboarding redesign. Need better activation metrics. Sarah to investigate options.

Three sentences. Zero of them executable.

Compare:

# Objective
Lift onboarding activation (signup → activated within 24h) from 31% to 45%.

# Context
- 7-step flow, drop-off spikes at the OAuth permissions screen
- 12 user interviews flag confusion about *why* we're asking for scopes
- Mobile is 62% of new signups

# Constraints
- SOC2 in scope — no new PII fields without legal review
- No backend schema changes this sprint
- Must keep existing analytics event names (PostHog)

# Tasks
1. Three redesign concepts targeting the OAuth screen specifically
2. Wireframes for the top concept
3. Instrumentation plan: events, properties, funnel definition
4. Implementation sketch in Next.js + Tailwind
5. A/B test plan with sample-size math

# Inputs
- /design/onboarding/current.fig
- /analytics/funnels/onboarding-q1.csv
- /research/oauth-interview-notes.md

# Output Format
- Concepts as Markdown + Figma frames
- Implementation plan as a PR description in /agent-runs/onboarding-redesign/

# Owner of Review
@sarah — signs off before any code merges

# Verification
- Concepts reviewed by design before wireframes
- Implementation runs behind a flag; canary 5% for 48h

The first version requires Sarah to do hours of translation work before anything happens. The second is a self-contained input that a coding agent, a research agent, or a junior PM can start on in the next five minutes — and produce something a human can react to before the day ends.

Who writes it, and when

This is the part most "prompt as artifact" essays skip.

Nobody hand-types this during the meeting. The realistic workflow:

  1. The meeting is transcribed (Granola, Fathom, Otter, native Zoom — pick one).
  2. In the last five minutes, the facilitator says: "What's the artifact?" — names the objective and the owner of review, out loud.
  3. After the meeting, an LLM compiles the transcript plus the named objective into the artifact template.
  4. The owner edits it for thirty seconds and commits it.

The meeting doesn't get longer. The note-taker job goes away. The artifact exists before anyone has had lunch.

What happens when the prompt is wrong

It will be wrong. That's the design assumption.

Prompt artifacts industrialize execution and industrialize mistakes if you don't put a verification loop next to them. The loop has four parts, and it's the part most teams skip:

  1. Dry run before write. Agent describes what it's about to do; human reads the plan.
  2. Small blast radius first. Branch, flag, canary, draft — never main.
  3. Diff review. A human reads the output against the artifact's stated objective.
  4. Provenance trail. The artifact, the agent run, and the resulting PR are linked. Audit asks "why did we do this?" — the answer is one click.

Without this loop, you don't have an AI-native org. You have a faster way to ship the wrong thing.

Governance, briefly

Three things compliance and legal will ask the first time you do this:

  • Where is the decision logged? Answer: the artifact lives in git; the agent run links back to it; the PR links to both.
  • Who signed off? Answer: the named reviewer in the artifact, recorded in the PR's approval.
  • Can we replay this for an audit? Answer: yes — artifact, transcript, agent run, diff, deploy log, all linked.

If you can't answer these three questions, you're not ready to let agents touch anything regulated. Use this pattern for internal tooling, research, dashboards, and prototypes first. Earn the governance story before you point it at the regulated path.

The small-team version

If you're solo, you don't have meetings. You have your own head. Same pattern, smaller:

End each work block by writing the next block's artifact — objective, context, constraints, tasks, output format. Past-you specs the work. Future-you (and the agent) executes it. The discontinuity between "I had an idea in the shower" and "the code is running" is the friction you're trying to remove.

For a two-person team, the artifact replaces the "quick sync." For a forty-person team, it replaces the recap, the standup, and three follow-up Slack threads.

The starting template

Steal this. Paste it at the bottom of every meeting agenda. Fill it in during the last five minutes.

# Objective
<the single outcome this meeting exists to produce>

# Context
<what the executor — human or agent — needs to know, with links>

# Constraints
<hard limits: compliance, scope, dependencies, deadlines>

# Tasks
<numbered, specific, independently executable>

# Inputs
<links, files, datasets, prior artifacts>

# Output Format
<exactly what "done" looks like, and where it lands>

# Owner of Review
<the human who signs off before anything ships>

# Verification
<dry run, flag, canary, diff review — pick the ones that apply>

The new meeting question

Not: "Who's taking notes?"

Better: "What's the artifact, who owns review, and how do we verify it?"

A meeting in 2026 still needs humans for the hard parts — judgment, taste, prioritization, ambiguity, relationships, the call that doesn't have a right answer. (For more on that, see The Stuff AI Can't Do.) What it no longer needs is a human pipeline to translate the easy parts into execution.

The meeting was never the work. The translation was. You can stop doing the translation by hand.