Another Nail in the Coffin for Tooling vs Prompting

Using Claude.AI to Generate a Workshop Presentation In Code

By Bob Matsuoka

Let's Start With the Real Shift

This isn't just a story about presentation software. It's a story about how prompting—paired with the right AI—has (or will) outpaced traditional tooling for certain creative workflows. That might sound like hyperbole. It's not. This is what it actually looks like to build a live, code-driven presentation with Claude.AI instead of PowerPoint.

Spoiler: it worked better than expected. And it changed how I think about software interfaces entirely.

The Origin Story: How It Started

I wanted AI's help to build a workshop presentation. I needed to view the final output in slide form while still being able to edit it collaboratively—with AI assistance along the way.

So I did what most folks would:

• Started writing in ChatGPT (fine-tuned on my voice).

• Exported as Markdown.

• Planned to convert to PPTX, then Google Slides.

• Used Marp to render slides from Markdown.

It worked. Technically. But it also felt like forcing a square peg into a round workflow. I kept jumping between formats, tools, and context. Every time I wanted to iterate—add a section, move things around, rephrase—I lost momentum. I lost the thread.

That's when I asked Claude for help.

From Slides to Source Code

Claude handled the entire spec and slide generation natively, in Markdown and HTML. It let me:

• Refactor sections like code.

• Inject or abstract content in blocks.

• Reuse and remap ideas across slides.

• Stay in one continuous prompt chain.

Even better: when I needed layout or formatting help, Claude handled it like a dev assistant would. Instead of guessing which GUI toggle to hit, I could just ask it to style a slide as a 2-column layout, or bold only the first line of a list. Done.

In short: the whole workflow felt like (AI agentic) writing software. And if you've worked with this model, you know how much leverage that gives you.

(Note: Context windows limit this type of work — many more than 15 slides and you run into issues. There are workarounds, but this will be less of an issue as context windows grow.)

The Workflow: Research → Spec → Code

Let's break it down:

1. Research: I prompted Claude to pull relevant workshop insights, frameworks, and supporting examples.

2. Specification: I outlined the slide deck structure with titles, goals, transitions—like an API schema.

3. Generation: Claude produced the slideshow in React, generating code underpinnings and styled components.

4. Iteration: I added, edited, and re-ordered content by prompting changes. Not dragging boxes around. Changes rendered instantly in a live Markdown previewer.

5. Deployment: The final slides lived in a clean HTML format, powered by Marp. I could serve them anywhere, version them, and tweak with minimal friction.

Why This Matters (It's Not Just Slides)

Here's the punchline: this isn't about slides at all. It's about the trendline away from GUIs and toward conversational software development.

More specifically:

• Tooling is constrained by UX affordances. Prompting isn't.

• Tooling adds friction when the medium is still evolving. Prompting adapts.

• Tooling requires learning the tool. Prompting lets you describe intent.

In this case, Claude generated the entire presentation in React—not just Markdown or HTML. That made it more productive than Slides + UI. Not just faster. Not just easier. Actually more capable.

That's a big shift.

This Isn't Just My Wild Observation

The shift I'm describing is happening across multiple creative domains:

Adobe reports that more than 75% of Photoshop users now use their AI features. These aren't just minor enhancements—they're completely different workflows that transform the relationship between designer and tool.

According to a Stanford/MIT study with 5,000+ customer support agents, workers with just two months of experience who used AI support performed as well or better than agents with over six months of experience working without AI. What's striking here? The interface is text, not buttons and menus.

Prompting as the New UX

This experience pushed me to a simple thesis: Prompting is evolving into a full-spectrum user interface.

Just like we moved from Dreamweaver to VS Code, we're now moving from "designing with tools" to "composing with language". In that world:

• Prompts are the spec.

• The AI is your pair programmer.

• The output is code (even if it looks like content).

If you've built anything serious with AI lately, you've probably felt this shift. And once you feel it, there's no going back.

The Barriers Are Real (But Falling Fast)

Let's acknowledge the obvious: there are still limitations.

The Nielsen Norman Group points out that about half the population may struggle with what they call the "articulation barrier"—the challenge of expressing complex design needs through text. If you're not particularly good at describing what you want, traditional GUI tools still have advantages.

Then there's control and predictability. When you need pixel-perfect positioning or precise control over tiny details, GUIs still excel. Prompt-based interfaces can be unpredictable, with identical prompts sometimes yielding different results.

But here's the thing: these barriers are falling rapidly. New "visual prompt builders" are emerging. Hybrid interfaces are combining natural language with traditional controls. And AI models themselves are getting dramatically better at understanding vague or imprecise instructions.

So What's the Real Takeaway?

Tooling isn't dead—but it's no longer the king. For creative, structural, or AI-mediated workflows, prompting is not just competitive—it will become dominant.

It's faster. More expressive. Easier to evolve. And it puts the focus back where it belongs: on the thinking, not the clicking.

That said, the likely long-term direction isn't pure prompting either. It's MCP and agentic tooling—powerful tools still exist, but they're increasingly driven by AI, with humans guiding them through prompt-based intent. Think of it as human-in-the-loop orchestration, not tool abandonment.

We're not trying to be clever—we're trying to be effective. And this was way, way more effective.

If you’re interested in seeing the “slides” — leave a comment here or DM me.