How To Write Great Quill Template Descriptions

A template is the instructions you give Quill for turning a transcript into a note, an email, or a report. Most people write them like a form: "summarize the meeting, list action items, keep it professional." Then they wonder why the output reads like every other AI summary on the internet.

The fix for most of it is one rule: show, don't tell.

Don't describe the output you want. Put a literal example of it in the template: the headings, the bullets, the exact greeting and sign-off. Quill mimics the shape you give it. Hand it a skeleton and it fills the skeleton. Hand it an adjective like "professional" and it guesses. So below is the shape of a good template first, then the patterns I use to fill it in. Steal any of them.

The anatomy of a great template

Almost all of mine have the same bones, top to bottom:

1. Role & context: who you are and what this meeting is, and when it matters, who you're not.
2. The output, shown not described: the literal shape you want back, like headings, bullet counts, a table, or a scoring rubric. For an email, the actual greeting and sign-off in your voice.
3. How to work: the order of operations, like pulling the evidence before you score.
4. An out for missing data: what Quill should do when something isn't there, so it doesn't force an answer into your format. (And where to keep the speaker's exact words.)
5. The knobs: tone, length, words to avoid.

You don't need every section every time. Plenty of my templates are just 1, 2, and maybe 5. You add the rest when the output starts to annoy you, not before. Here's each part, with the version I actually use.

Start with the role: who it is, and who it isn't

The first line of almost every template I write is a one-line role. It changes everything downstream: the vocabulary, what counts as important, what gets cut.

I am interviewing potential senior designers for Quill Meetings.

Saying who you're not is just as useful. I advise a few startups, and on those calls I write:

I am advising this startup, NOT in my capacity as Quill CTO.

Leave that line out and Quill starts pitching Quill and recommending our stack. The "NOT" keeps it in the right seat. Any time the output takes on a stance you didn't ask for, naming the hat you're wearing usually fixes it in one sentence.

Show the output you want, don't describe it

For structured notes, write the exact shape: real headings, real bullet counts, real tables. Here are the bones of how I take startup notes:

## Company

3 bullets: what they do, stage, who's on the call.

## What's working

Up to 3 bullets.

## Risks

Up to 3 bullets.

## My take

A 2-3 sentence paragraph.

The bullet counts are the part that matters. Say "3 bullets" and you don't get fifteen bullets of transcript trivia. For anything comparative, give Quill a real markdown table with named columns. My deal memo template scores deals on a 1-3 scale:

| Dimension          | Score (1-3) | Notes |
|--------------------|-------------|-------|
| Team               |             |       |
| Market             |             |       |
| Product            |             |       |

Run that against a real pitch and the skeleton comes back filled in, same structure every time:

Deal Memo for [company] on June 12th

Category Details Round SizeTargeting ~$3M minimum, room to go higher IndustryAI meeting assistant for financial enterprises Est. Post-MoneyNot specified in the transcript. Co-InvestorsLead confirmed; a couple of angels interested Look at the Post-Money row. Quill told me it couldn't find the number instead of inventing one. That's the behavior you want, and it happened here on its own. It won't always, so making it reliable is its own tip, further down.

For evaluations, write a rubric

When the job is judgment — screening a candidate, scoring a pitch — vague instructions get you vague scores. So spell it out: named criteria, point bands, a total, and a recommendation that maps to something you'd actually do. From my engineering screen:

Score each area, then total to 25:

- Technical depth (0-10)
- Communication (0-10)
- Quill fit (0-5)

Bands:

  Strong 20-25  -> Advance to technical round
  Good   15-19  -> Advance, with reservations
  Weak   10-14  -> Pass
  Poor   <10    -> Pass

End with the band, the total, and the one-line recommendation.

On a real 45-minute screen, that turns a rambling conversation into something you can grade:

Design Philosophy & Taste (25 pts)

Philosophy - simplicity vs. power:

Her process is "ship and learn ... do something dirty and quick first
and then test it with users to get their real feedback so I can quickly
iterate."

Broke a slow on-device AI flow into visible steps, like managing a human assistant.

Score: 14/15

Section: 21/25 - strong, practical philosophy focused on rapid, user-centric iteration.

Evidence first, cleaned-up quote, then the number, in that order, because LLM process as they write. If they write a number first they often try to justify it. If they write the evidence first, the number will be informed by the evidence.

Take the number with a grain of salt - LLMs are good at producing quotes and struggle with judgment calls. Asking for the number forces it to give you quality evidence, which you can then review and consider

Hard-code your voice with literal boilerplate

This is the big one for emails. If you want a note to sound like you, don't tell Quill to "use a friendly tone." Write the words you'd actually type. My advisor follow-up template literally contains:

Hey ____ & ____,



Great to catch up just now! Here's a quick summary of what we discussed:



[summary]



Cheers,

Michael

Even the blanks are instructions: the names go in the ____, figure them out from the call. You can use ____, {name}, [company], [date], <person>, whatever you like. Just pick one style and stick with it.

Here's a real result, off an actual advising call. I didn't write a word of the content, but it's my greeting, my sign-off, my register:

Hey Sam,



Great to catch up just now! Here's a quick summary of important points:



Angels make sense for your current stage - you need ~$300K, not $5M,

to prove the model

Send prototypes to the angels who've already shown interest

Prioritize the SDK earlier - the community of hackers around this will

drive growth



You mentioned your goals for the next few months include starting a beta

in January with 10 units, locking down manufacturing, and raising the

angel round.



Cheers,

Michael

The voice isn't in the bullets. It's in "Great to catch up just now!" and "Cheers, Michael" — the two lines I handed it verbatim.

Tell it how to work, not just what to produce

Give Quill the order of operations, and make it look before it judges:

Start by pulling the key details from the call - what they built, how they

described it, the tradeoffs they raised. Include key quotes (cleaned up).

THEN give the score.

Making Quill read the transcript before it scores beats "give me a score" every single time. And "(cleaned up)" is doing quiet work there: fix the ums and false starts, keep the substance.

Give it an out when the data isn't there

No meeting ever covers everything you planned for. Here's the trap: if you don't tell Quill what to do with a gap, it papers over the gap anyway. It'll invent a score, pad a section with filler, or answer a question nobody asked.

So give it somewhere to go. The easiest version is just letting it skip the section:

Write a "Risks" section if risks came up - and do not include it at all if

there's no related discussion in the conversation.

If it still jams the section in, hand it an exact thing to write instead:

Write a "Risks" section. If there was no related discussion, just write

`Not discussed`.

For a rubric the out is a default value. My designer screen says: If we didn't get to the app/interface question, give them a 7 and note it wasn't covered. Either way, you've answered the question Quill would otherwise answer badly on its own: what do I do when there's nothing here?

Preserve the speaker's actual words

Some notes die in paraphrase, and status updates are the worst case. My team's daily Slack update template says:

Stay as similar as possible to the actual specific words used. Remove ums,

ahs, and false starts, but don't reword. This is their update, not yours.

Run that on a rambling spoken update and you get something the team can skim in ten seconds, still in the person's own words:

DONE

Demo'd new custom webhook automations (beta)

Supports auth, test runs, and run history for debugging

Helped a teammate get the beta build running



TODO

Roll out automations to the rest of the customer's team after next

week's prod build

Build the enterprise "headless client" for shared transcript collection



Plans & Timelines

Next week: automations ship to prod

That reads like the person who said it. Paraphrase it and you'd get a robot summarizing them, which nobody wants in a standup.

The small knobs: tone, length, banned words

The little settings add up fast.

• Tone: "casual, friendly" or "dry and factual."
• Length: "a 2-3 sentence paragraph", "one line each."
• Banned words: my coaching-session template says do not use the word "should" in the framing. Coaching that leans on "should" feels like nagging, so I took the word away. Reach for this when a word keeps cropping up and bugging you.

And headers can carry instructions. A heading like:

## Specific suggestions for <person>, including topics for the next session

does two jobs at once: it structures the output and tells Quill what to put there.

Test it on 3-5 past meetings, then iterate

This is the step everyone skips, and it's the one that actually makes a template good. No template is right on the first try. Before you lean on one, run it against three to five old meetings, a short call, a messy one, a normal one, and read the results with a critical eye. The problems jump out fast: too many bullets, a section that's always empty, a tone that isn't yours.

Then fix the one thing and run it again. You don't have to start strict, either. Begin with the rough shape, let real meetings show you what breaks, and add the table or pin the bullet count or write the edge-case rule right where it turned out you needed it.

None of my templates were any good the first time. They got good around the third or fourth round, after I'd gone back and fixed whatever kept bugging me. That's the whole method. And it's why the templates that work best are always the ones that sound like a person wrote them — because a person did, over and over, until they fit.

Ready to build your own? Open Quill and turn your next meeting into a note that sounds like you.