# AI at Work — Demo Brief

*A menu of three use cases, each shown two ways: **run it live** or **show pre-made materials**. Pick per your time, your appetite for risk, and what you want to signal. Everything here is designed so the human — your judgment — stays the star. The AI is leverage, not the act.*

---

## Read this first: the story, not the tools

Senior leaders won't remember which model you used. They'll remember the **shape of how you now work**. So tell it as an arc, not a tool tour:

> **Ideate → Align → Deliver.** Three moments in the product lifecycle where I've put AI to work — and in every one, it sharpens my judgment instead of replacing it.

- **Ideate** — I get from a messy pile of notes to a defensible, *already-pressure-tested* strategy in an afternoon, not a fortnight.
- **Align** — I make a roadmap something people can *click and feel*, so a room stops arguing about abstractions and aligns on the actual experience.
- **Deliver** — I keep execution honest against the strategy and catch team-level risk early, before it costs a quarter.

**The real message to the room:** *"This is how I think a modern product org should operate — and I'm not waiting for permission to live it."* That positioning — a leader already experimenting to stay ahead for his team — is worth more than any single output on the screen.

---

## The format decision: live vs. pre-made (my honest take)

**Default to pre-made materials, and go live only on the one or two beats that are fast and bulletproof.** Three reasons:

1. **Harness risk.** These use cases lean on multi-turn tool use — clarifying-question loops, running a script, calling Jira. That only works if Chase's suite has a genuinely agentic harness (tools, file handling, multi-step). You don't fully know that yet, and a demo is the worst place to find out.
2. **Time risk.** The interesting runs take *minutes* and several back-and-forths. That's death on a live exec call.
3. **Ambition upside.** Pre-made lets you show things Chase's tooling *can't do yet* — which is exactly the "forward-leaning leader experimenting outside the walls" signal you want. Live caps you at what runs today; pre-made lets you show where this goes.

| | Run live | Show pre-made |
|---|---|---|
| **Best for** | A single fast, reliable beat that proves it's real | The ambitious, multi-step, or data-sensitive cases |
| **Wow factor** | High *if it works* | High and *reliable* |
| **Risk** | Latency, auth, a bad generation, a stalled harness | Low — you rehearse the exact thing they'll see |
| **Signals** | "This runs today" | "I'm ahead of where our tooling is" |

**My recommendation:** open with a *short* live moment to establish it's real (the clarifying-questions exchange in Use Case 1 is perfect — it's fast and it's the magic), then switch to pre-made artifacts for the ambitious parts. Always have a screen recording of anything "live" as a silent backup.

> One caution to carry throughout: **have him internalize *why* each design choice exists** (the clarifying loops, the sanitized data, the self-contained HTML). A slick demo he can't defend under a senior "why?" is worse than a modest one he owns cold. Each use case below has a **"If they push back"** line for exactly this.

---

## Use Case 1 — **Napkin → Narrative**
*Alt name: "The Reading Room." Idea → read-ready strategy doc → pressure-tested by the best.*

**What it is.** A skill that turns messy meeting notes, context docs, and a rough goal into a strategy document written for a read-and-react session (the Amazon-style narrative). Then it runs that doc through an archive of the best product thinkers to stress-test it *before* it ever reaches a human reviewer.

**How it works (the flow that matters):**
1. **Intake** — dump the raw notes, any context docs, and the goal.
2. **Clarify — round 1 (before writing a word).** It asks 4–6 sharp questions: *Who's the reader and what decision am I asking them to make? If they remember one thing, what is it? What's genuinely new vs. table stakes? What's out of scope? What would make a skeptic say no?*
3. **Draft** — produces a one-pager *or* a 3–5 page narrative, and it *tells you which it chose and why* (thin/tactical context → one-pager; rich/strategic → narrative).
4. **Clarify — round 2** — targeted questions at the weakest parts of its own draft.
5. **Stress test** — runs the doc through the Lenny's-archive analyzer (a real script Gabe already built — runs in Claude Code / terminal), simulating a panel of top operators poking holes.
6. **Output** — the final read-ready doc *plus* a short "how this got sharper" appendix showing what the panel changed.

**Why senior leaders care:** the artifact isn't the prose — it's that a doc reaching their desk has *already survived a review*. That's a leader who respects their time.

**▶ Live version.** Pre-load the context off-camera. Live, run only **steps 2–3**: paste the goal, let it ask its clarifying questions, answer one or two out loud, watch the first draft appear. That's ~2 minutes and it's the whole magic. Have the Lenny's-panel output *pre-baked* to reveal on the next slide.

**📄 Pre-made version.** A single before/after artifact: **messy input** (left) → **the clarifying Q&A** (middle — this is the star; it shows the AI *interrogating*, not typing) → **final doc** (right) → a callout box: *"What the panel changed."* Ships as a short scrolling doc or 3 slides.

**If they push back — "Isn't this just ChatGPT writing your docs?"**
> "The prose is the cheap part. The value is the interrogation — it asks me the questions *you'd* ask, before I've burned a week. And it runs the draft past a panel of the best operators in the industry, so what reaches you has already been stress-tested. I'm shipping you a second draft, not a first."

---

## Use Case 2 — **The Playable Roadmap**
*Alt name: "Strategy You Can Click." Crawl / walk / run, with a working prototype beside each stage.*

**What it is.** A skill that turns a strategy deck (or the narrative from Use Case 1) into a single interactive HTML page. A stage selector — **Crawl → Walk → Run** — sits on top. Below it, a split view: **left = the strategy for that stage** (what changes, the value unlocked, the platform capabilities required, the controls); **right = a clickable prototype** of the product at that stage. Advance the stage and *both evolve* — so viewers don't read the roadmap, they **experience the strategy maturing**: the UX getting richer, the capabilities stacking up, the value compounding.

**Why senior leaders care:** decks make strategy abstract and every reader imagines something different. When twelve people can *click* crawl/walk/run, they stop debating words and align on the actual experience. It compresses weeks of alignment meetings.

**▶ Live version.** *Don't generate it live* — design output is variable and slow. Instead the "live" is: open the pre-built HTML and **interact** — scrub the stages, click the prototypes. That's live enough and reliably impressive.

**📄 Pre-made version.** The HTML file *is* the deliverable. **You do not need to publish anything internally** — it's a single self-contained file (all styling and logic inline, no server, no external calls, no data leaving the laptop). You double-click it, it opens in any browser, you screenshare. That directly kills the "can I publish HTML at Chase?" worry — you don't publish, you open. (There's a working sample in `samples/playable-roadmap-sample.html` — an illustrative servicing-copilot roadmap. Swap the content for his real one.) Record a 60–90s screen capture as a backup in case a browser misbehaves on the call.

**If they push back — "Prototypes aren't the real product."**
> "Exactly — these are throwaway. The point isn't the pixels, it's the alignment. When the room can click through crawl/walk/run, we debate the real experience instead of twelve different mental models of one bullet point. It turns a month of alignment meetings into one session."

---

## Use Case 3 — **Priority Radar**
*Alt name: "Portfolio X-Ray." Is our effort actually going where we said our priorities are — and what's about to break?*

**What it is.** A skill that pulls historical Jira data (via the suite's Jira connection) and answers two questions leaders actually lose sleep over: **(1) Is our time aligned to our stated priorities?** (effort vs. intent) and **(2) Where are the early-warning hotspots?** (rising work-in-progress, reopen rates, churn — the leading indicators of slipping delivery and team strain).

**How it works (the two-sided interview is the trick):**
1. **Interview — before touching data.** What decision should this dashboard drive (quarterly planning? an exec update?)? What *are* the 3–5 priorities? What does a "hotspot" mean to you? Who's the audience?
2. **Pull** the Jira data.
3. **Interview — after seeing the data.** Come back with what's actually measurable *and* what's surprising: *"You named Priority X, but only ~8% of story points map to it. Also, Team A's reopen rate is 3× the others and rising — worth a look."* Then confirm the cuts and categories together.
4. **Produce** the dashboard: the effort-vs-intent view, flagged hotspots, and a short *"so what / do this"* narrative.

**Why senior leaders care:** most dashboards answer questions nobody asked. The before-*and*-after interview forces the metric to serve a decision, then lets reality reshape it. It reads like an analyst, not a chart generator.

**⚠️ Two judgment calls to make before this one goes near an exec room:**
- **Sanitize.** Real Jira data means real people's work on a screen in front of leadership. Use anonymized team labels or a sample dataset. Never live-pull real data on the call.
- **Frame it as team/system-level, never individual.** The burnout/morale angle is powerful but it's an HR/privacy landmine if it looks like surveillance of named people. Keep it to teams and systems, positioned as *protecting* delivery and people — not ranking them.

**▶ Live version.** *Not recommended with real data* (auth, latency, and sensitive named-individual data in front of execs). If live at all, use a sanitized sample and pull only a pre-tested view.

**📄 Pre-made version.** Build it from sample or sanitized data; present the dashboard as an artifact plus the one insight that would *change a decision*. Lead with the method and the decision it changed, not the raw numbers.

**If they push back — "Is this surveillance of my teams?"**
> "No — deliberately not. It's team- and system-level, and it's an early-warning tool to protect delivery and the people, not to rank anyone. I kept it away from individual performance on purpose — that's an HR conversation, not a dashboard."

---

## Suggested running order (for ~15–20 min)

1. **Open with the arc** (60s): "Three moments — ideate, align, deliver — where AI now sharpens my judgment."
2. **Use Case 1, live-ish** (3–4 min): run the clarifying-questions moment live to prove it's real, then reveal the pre-baked panel stress-test.
3. **Use Case 2, pre-made** (4–5 min): open the Playable Roadmap and *click through it*. This is your visual peak.
4. **Use Case 3, pre-made** (3–4 min): the Priority Radar dashboard + the one decision it changed. Land the "protect the team" framing.
5. **Close** (60s): "None of this replaces the hard part — the judgment. It just gets me to the judgment faster, and lets me bring the org along. This is where I think we should be pointed."

## What to have ready (the boring insurance)
- A **screen recording** of anything you plan to run live.
- All artifacts as **local files** open and ready — no live internet dependency for the pre-made parts.
- One-line answers to the three "if they push back" prompts, memorized.
- A backup slide of the **arc** so if all tech fails, the *story* still lands.

## Appendix: the skills
Copy-pasteable templates (recreate inside the suite if files can't be forwarded):
- `skills/napkin-to-narrative/SKILL.md`
- `skills/playable-roadmap/SKILL.md`
- `skills/priority-radar/SKILL.md`
- Sample: `samples/playable-roadmap-sample.html`