<!--
  Deck Builder Pack
  From TemplatedAI.io — all the prompts the gurus sell, rebuilt in plain
  language and honestly flagged. 7 skills, 0 tested. Blank page to a deck you can present — define the point, fix the order, one point per slide, honest charts, a polish pass, then export and the lines that open and close the talk.

  HOW TO USE: paste this whole file into a Claude Project, ChatGPT Project,
  Gemini Gem, or Cursor as knowledge/instructions. Then ask your AI to use
  a skill by name.

  HONESTY: "tested: no" in a skill means nobody has personally run it and
  pasted a real result yet. Use it — just judge the output yourself.
-->

---
name: Deck Foundation
category: content
works_with: [claude, chatgpt, gemini]
difficulty: plug-and-play
version: 1.0
source: adapted (viral "7 deck prompts" pack, rewritten; credential flattery removed)
tested: no
---

# Deck Foundation

## What it does
Builds the first real draft of a presentation — but only after the AI asks you the questions that make it yours: your goal, your audience, the action you want. It sets up the narrative arc every other deck step builds on.

## When to use it
- Starting any presentation from a blank page
- Your decks come out generic because you skipped defining the point
- Before touching colours or layout — structure first

## The skill
```
Act as a senior presentation designer. Rules: don't start building
until you understand my situation — ask first; no filler slides; a
real call to action, never a generic "thank you" slide.

I need a [NUMBER]-slide presentation about [TOPIC], for [AUDIENCE —
their role and what they actually care about].
Tone: [BOLD / CLEAN & MINIMAL / WARM — pick one].

Before building anything, ask me clarifying questions about: my goal
for this deck, the one action I want the audience to take afterward,
and any constraints (time, format, what they already know).

Once you have enough, build the full deck with:
- a title slide that signals the value of what follows (not just a topic)
- a narrative arc: problem → insight → solution → result
- a closing slide with one specific, clear call to action
For each slide give me the headline, the key points, and a one-line
note on what it should look like.
```

## Example output
[TO FILL AFTER TESTING]

## Tweaks
- Answer its clarifying questions specifically — that's the whole difference between a template-feeling deck and one built for your situation
- Keep this as your first step; the consistency, chart, and polish skills all run on the draft this creates
- Works best in an AI that can render slides/artifacts, but the structure is useful even as plain text you build elsewhere

---

---
name: Deck Story Order
category: content
works_with: [claude, chatgpt, gemini]
difficulty: plug-and-play
version: 1.0
source: adapted (viral "7 deck prompts" pack, rewritten)
tested: no
---

# Deck Story Order

## What it does
Audits the whole flow of a presentation as if watching it live — where the story jumps, where attention drops, which slides are redundant — and proposes a better order with the reasoning. Well-designed slides in the wrong sequence still fail to persuade.

## When to use it
- Your slides look good individually but the deck doesn't land
- You've reordered it five times and can't tell if it flows
- Before a high-stakes presentation, as a structure check

## The skill
```
Act as a presentation reviewer watching my deck live for the first
time. Rules: judge the flow, not the visuals; be honest about weak
transitions; don't invent content — work only with the slides I give.

My slides in order: [PASTE SLIDE TITLES + one line each, in order]
The one action I want the audience to take: [STATE IT]

Tell me honestly:
1. Does it flow problem → insight → solution → result, or does it
   jump around? Name where it breaks.
2. The drop point: where would the audience most likely lose
   interest or get confused about where this is heading?
3. Redundancy: any slides that repeat a point or could merge
   without losing anything.
Then propose a better slide order if it needs one, and explain the
reasoning for each move — not just the new list.
```

## Example output
[TO FILL AFTER TESTING]

## Tweaks
- Run this after you have a full draft, not while you're still writing slides
- Feed it just titles + one line each — it's about sequence, not detail
- If the reorder feels wrong in your gut, say so and ask it to defend both orders; you know the room, it doesn't

---

---
name: One Point Per Slide
category: content
works_with: [claude, chatgpt, gemini]
difficulty: plug-and-play
version: 1.0
source: adapted (viral "7 deck prompts" pack, rewritten)
tested: no
---

# One Point Per Slide

## What it does
Fixes the most common slide mistake — too much on it — by finding the single thing the audience must remember, rewriting the slide around only that, and suggesting a visual to replace the paragraphs you cut.

## When to use it
- Any slide with more than ~20 words of body text
- A slide you keep cramming because "it's all important"
- Before finalizing, run it across every dense slide

## The skill
```
Act as a presentation editor whose rule is one point per slide.
Rules: find the single point, cut the rest, don't add new claims;
suggest a visual only if it genuinely replaces text.

Here's an overloaded slide: [PASTE / DESCRIBE THE FULL SLIDE CONTENT]

Give me:
1. The one point: the single thing the audience must walk away
   remembering from this slide. If there are two, tell me it should
   be two slides.
2. The rewrite: the slide rebuilt around only that point — a sharp
   headline and the few words that support it, everything else cut.
3. One visual (an icon, a simple diagram, an image) that could
   replace some of the remaining text, so the slide communicates
   through weight, not paragraphs.
4. The speaker note: the detail I cut from the slide, moved to what
   I SAY instead — so nothing's lost, it's just off the slide.
```

## Example output
[TO FILL AFTER TESTING]

## Tweaks
- The 20-word rule catches most overloaded slides — if it's over, run this
- Cut text usually isn't deleted, it's demoted to your speaker notes; the slide is the billboard, you're the voiceover
- Two points fighting on one slide is the tell you need a second slide, not smaller font

---

---
name: The Slide Chart
category: content
works_with: [claude, chatgpt, gemini]
difficulty: plug-and-play
version: 1.0
source: adapted (viral "7 deck prompts" pack, rewritten)
tested: no
---

# The Slide Chart

## What it does
Turns raw numbers into a chart that communicates instantly — the right chart type for your specific data, matched to your deck's style, topped with a plain-language headline that states the takeaway before anyone reads the axes.

## When to use it
- A slide has a table of numbers nobody will actually read
- You're not sure whether it should be a bar, line, or something else
- Any data point that matters enough to earn its own slide

## The skill
```
Act as a data-presentation designer. Rules: pick the chart that fits
THIS data, not a default; the takeaway comes first, in words, above
the chart; never dress up a number that isn't real — use only what
I give you.

My raw data: [PASTE NUMBERS / STATS / DATA POINTS]
What I want the audience to understand from it: [THE POINT]
My deck's colours/style: [DESCRIBE OR PASTE]

Give me:
1. The chart type that communicates this most clearly (bar, line,
   comparison, or other) and WHY it beats the obvious default here.
2. The chart built clean, in my deck's palette — no clutter, no
   3-D, no unnecessary gridlines.
3. One short, bold headline above it stating the single most
   important takeaway in plain language, so the point lands before
   the chart is even read.
4. What to cut: any data on this slide that doesn't support that
   one takeaway.
```

## Example output
[TO FILL AFTER TESTING]

## Tweaks
- One chart, one takeaway, one slide — if the data makes two points, that's two slides
- The headline does the work; if you removed the chart, the headline alone should still make sense
- Read the dataviz principles in the library's design guidance if you want the chart to read well in both light and dark

---

---
name: Deck Polish Pass
category: content
works_with: [claude, chatgpt, gemini]
difficulty: plug-and-play
version: 1.0
source: adapted (viral "7 deck prompts" pack, rewritten; two review passes merged into one)
tested: no
---

# Deck Polish Pass

## What it does
Runs your finished draft through one review that catches the two things that make a deck look amateur: inconsistency (fonts, colours, spacing, and wording drifting slide to slide) and design weakness (cluttered slides, weak hierarchy, nothing for the eye to land on). One pass, one prioritized fix list.

## When to use it
- You have a full draft and it's "fine" but not sharp
- Right before you present or send it
- After a reorder or a round of edits, to catch new drift

## The skill
```
Act as a presentation design reviewer doing a final polish pass.
Rules: work only with the slides I give you — don't invent new
content or claims; be specific about which slide and what to change;
sort fixes by impact, not by slide order.

My deck, slide by slide: [PASTE TITLES + KEY TEXT PER SLIDE, or
DESCRIBE EACH SLIDE'S LAYOUT]
My intended style: [FONTS / COLOURS / TONE — or "you tell me what
it's currently drifting toward"]

Review it on two things and give me one combined fix list:

CONSISTENCY
- Where do fonts, colours, spacing, capitalisation, or wording
  style change between slides when they shouldn't?
- Is the same idea named the same way throughout, or does the
  vocabulary drift?

DESIGN
- Which slides are cluttered or have no clear focal point?
- Where is the visual hierarchy weak — nothing tells the eye what
  to read first?
- Which slides are carrying their weight and which feel like filler?

Then give me a single list of fixes ordered by impact — the change
that most improves the deck first — each one naming the slide and
the exact adjustment. Flag anything you're unsure about rather than
guessing.
```

## Example output
[TO FILL AFTER TESTING]

## Tweaks
- Run this once on the whole deck, not slide by slide — consistency problems only show up in comparison
- "Ordered by impact" is the point; if you only have time for three fixes, do the top three
- If it flags a slide as filler and your gut agrees, cut it — a shorter deck that lands beats a complete one that drifts

---

---
name: Deck Delivery
category: content
works_with: [claude, chatgpt, gemini]
difficulty: plug-and-play
version: 1.0
source: adapted (viral "7 deck prompts" pack, rewritten; hype removed)
tested: no
---

# Deck Delivery

## What it does
Handles the last mile: gets your deck out of the AI in a format you can actually present (or gives you the clean structure to rebuild it in your own tool), and writes the two lines that carry a talk — a natural opening that isn't "hi, today I'm going to talk about," and a closing that leaves them with the one thing you want remembered.

## When to use it
- The content is done and you need it in PowerPoint, Keynote, Google Slides, or PDF
- You freeze on the first and last thing to say
- You're handing the deck to someone else to present

## The skill
```
Act as a presentation coach handling the handoff. Rules: don't add
new content — work from the deck as it is; the opening and closing
must sound like a person talking, not a slide read aloud; no hype,
no "unlock," no fake urgency.

My finished deck: [PASTE OR DESCRIBE THE SLIDES]
Where I'm presenting it: [ROOM / VIDEO CALL / SENT AS A FILE]
The tool I'll finish it in: [POWERPOINT / KEYNOTE / GOOGLE SLIDES /
PDF / just tell me the best option]

Give me:
1. EXPORT: the cleanest way to get this deck into my tool. If you
   can produce the file or a copy-paste-ready outline (slide title,
   body, and layout note per slide), do that. If you can't produce
   the file itself, say so plainly and give me the structure to
   rebuild it fast — don't pretend to attach something.
2. THE OPENING LINE: one natural way to open that earns attention
   in the first ten seconds — a question, a specific moment, or a
   surprising fact from my own content. Not "today I'll be talking
   about."
3. THE CLOSING LINE: one strong close that lands the single thing I
   want them to remember and points at the call to action already
   in the deck. Not "thank you, any questions."
4. THE ONE-LINE VERSION: if someone asked "what's your deck about?"
   in a hallway, the single sentence I'd say.
```

## Example output
[TO FILL AFTER TESTING]

## Tweaks
- Most AIs can't hand you a real .pptx file — if it claims to, treat that with suspicion and ask for the outline instead, then build it in your tool
- Say the opening and closing out loud before you accept them; if they feel like a script, ask for a plainer version
- The one-line version is worth keeping even if you skip the rest — it's your answer every time someone asks what you're presenting

---

---
name: Build a Deck
category: content
tools_required: [Any AI chat (Claude, ChatGPT, or Gemini) — one that can render slides/artifacts helps; your normal slide tool for the final file (PowerPoint / Keynote / Google Slides)]
cost: free tiers of the major AI chats cover this end to end
time_to_set_up: a couple of hours for your first real deck, faster after
version: 1.0
source: adapted (viral "7 deck prompts" pack, rewritten; credential flattery and hype removed)
tested: no
---

# Build a Deck

## What it does
Chains six skills into one path from blank page to a deck you can present: define the point, get the sequence right, sharpen each slide, turn data into charts, polish for consistency and design, then handle export and the words that open and close the talk. Each step runs on the output of the one before it, so you never start a slide from nothing.

## What you need
- An AI chat (any major one). One that can render slides or artifacts is nice for previewing, but the whole pipeline works as plain text you build in your own tool.
- Your normal slide tool for the final file.
- The six skills: Deck Foundation, Deck Story Order, One Point Per Slide, The Slide Chart, Deck Polish Pass, Deck Delivery.

## The workflow
1. **Deck Foundation** — start here, always. Answer its clarifying questions specifically; that's what makes the deck yours instead of generic. Out comes your first full draft: title, narrative arc, key points, a real call to action.
2. **Deck Story Order** — feed it just your slide titles plus one line each. It audits the flow as if watching live and proposes a better sequence with reasoning. Fix the order before you polish anything — good slides in the wrong order still fail.
3. **One Point Per Slide** — run this on every slide over ~20 words of body text. It finds the single thing the slide must land, rewrites around it, and moves the rest to your speaker notes.
4. **The Slide Chart** — for any slide with real numbers, turn the table into one chart with a plain-language takeaway headline. One chart, one point, one slide.
5. **Deck Polish Pass** — run once on the whole draft. It catches consistency drift (fonts, colours, wording) and design weakness (clutter, weak hierarchy) and hands back a fix list ordered by impact. Do the top fixes first.
6. **Deck Delivery** — get it into your slide tool (or a clean outline to rebuild from), and write the opening line and closing line that carry the talk. Say them out loud before you accept them.

## Maintenance habits
- Keep step 1's answers. Next deck, you reuse your audience and goal framing instead of redefining it from scratch.
- Save your best Polish Pass fix lists — the same drift tends to recur, and you learn to avoid it in the draft.
- Trust the room over the model: if a reorder or a cut feels wrong in your gut, it can defend both options, but you're the one who knows the audience.
- Don't skip Foundation to save time. Every later step assumes a defined point; without one they just tidy a deck that was never aimed anywhere.

## What we stripped
The source pack was genuinely good — rare enough to say so — and most of it survived the rebuild intact. What we cut: the "charge $2,000+ per project" credential flourish that framed the whole thing as a way to look like an expensive designer, and the "so it doesn't look AI-generated" hype that promised the output would pass as human-made work. The skills stand on what they actually do — clearer structure, one point per slide, honest charts — without the money and status framing. We also merged the source's two separate review prompts (brand consistency and design critique) into a single Polish Pass, because running one focused review beats running two that overlap. Every skill here is still marked tested: no until the deck it builds has been run for real.
