Signing up to speak at conferences is fun until the conference date starts approaching and you realize you still have to write and practice your talk. For me, writing the talk isn't the hard part. I have a process of talking to myself on a peaceful walk (or even in the shower), recording my voice, and then inserting the demos afterward. The part I often procrastinate is making the slides. Creating slides used to be fun, but as I’ve grown my career and my family, it's no longer a good use of my time.
I've looked for a way to automate slide generation, but most options have been fragile. They generally struggle with formatting and taste. However, a few months ago, some of my teammates at Block discovered the frontend slides skill and introduced me to it. This skill enables agents to build out HTML presentation decks that can be exported as PDFs or PowerPoint presentations.
Agent Skills
If you're not familiar, agent skills are markdown files that provide instructions for the agent to understand how to use a tool (i.e., a CLI or an MCP server). This way, your agent immediately knows what commands to run and how to navigate the tooling when you make a request.
How I Use the Frontend Slides Skill
As I mentioned, I already have my talk transcribed, which gives me a talk track to follow. I typically give the transcript to an agent and ask if there are any parts that don't make sense or any gaps for the audience.
Once the talk track is polished, I give the copy to my agent and prompt it to use the frontend slides skill to build a deck based on the track. I prefer to use Claude Code for this task, as it seems to work really well with the frontend slides skill, but any agent that supports skills should work. The agent then produces a beautiful slide deck for me. It really doesn't look bad or overly generic at all. It has various themes to choose from, and since it's generated with HTML, CSS, and JavaScript, I can prompt my agent to edit parts like making the font bigger, changing colors, and so on.
Here's an example:
My favorite thing to add is a presenter view. It doesn't generate that view by default, but I do like to take a peek at my notes as I speak. So I usually tell my agent to implement that view if I press a key like the letter "P," and I make sure it syncs with what everyone else can see. Then, I upload my deck to GitHub Pages. Goodbye, Canva, PowerPoint, and Google Slides.
How Entire Enhanced My Workflow
Let me rewind for a second and introduce you to Entire. Entire is the company I work for. We're building the next developer platform for the AI-native software development lifecycle. The team recognized that agents have changed our workflows, so the infrastructure we use should change too.
Our first tool is a CLI that captures prompts, agent responses, tool calls, and other session data from the work you do with an agent. That gives you a way to inspect what happened, rewind work from a past session, and stay accountable. For example, if a production outage ever happens, instead of saying, "Oh, the root cause is that my agent did it," you can actually track the decisions made between the agent and the person prompting it. I described this to someone at a conference the other day, and they boiled it down to version control for agentic work, which is honestly exactly what it feels like.
Now, it took me a while to see how Entire could make my workflow even better, but the founders opened my eyes. I can use Entire while I'm building out a demo and then use that captured work to help build the slide deck later. Entire has a command called entire dispatch. It generates a markdown summary of the work Entire captured between you and your agent in a repository.
For example, after experimenting with OCR in a repo, Entire generated this dispatch summary for me:
# Dispatch: blackgirlbytes/pretext-handwriting-demo
Shipped a full handwriting recognition demo built on Pretext, moving from
initial scaffolding to a polished scrapbook composition surface within a
single day.
## blackgirlbytes/pretext-handwriting-demo
### Handwriting Recognition
• Built draw-mode handwriting recognition as the core interaction surface.
• Added image upload as a second recognition path alongside the drawing
canvas.
• Implemented auto-recognition after drawing completes, removing the manual
trigger step.
• Added camera mode to round out the three input methods.
• Removed the explicit draw button to streamline the input UX.
### Scrapbook Composition Surface
• Introduced a scrapbook composition surface for arranging recognized text
and shapes.
• Integrated Pretext to handle obstacle-aware text flow around placed shapes.
• Added animated motion layer to the scrapbook background.
• Added resize handles to scrapbook shapes for direct manipulation.
• Matched scrapbook background typography to the handwriter component for
visual consistency.
• Moved scrapbook controls into the composition header to consolidate the
toolbar.
• Fixed scrapbook layout and output tab rendering, then simplified and
tightened tab spacing across multiple passes.
• Corrected background line wrapping and ensured background renders before
shapes are placed.
### API Key & Session Management
• Added session-based OpenAI key setup to avoid requiring environment-level
configuration.
• Hardened API key gate interactions to handle edge cases more reliably.
• Added environment key setup path as an alternative to session entry.
### Documentation
• Added project agent working rules and intent guidance early in the commit
sequence.
• Documented project setup and architecture in the README.
• Refined and clarified the README project description across two follow-up
commits.
All core features landed on main on April 1, 2026; the repo is in a
reviewable state.
That's helpful for me because building a demo usually takes a few days. I'll leave it, come back to it later, and then have to remember what I actually did, what mattered most, and which technical details are worth calling out. Instead of trying to reconstruct all of that from memory, I can use the dispatch summary, give it back to the agent, and ask it to make a strong slide that captures the main technical highlights of the demo. That saves me from having to recall every step I took days or even weeks later.
Beyond DevRel
My particular use case works best for folks in Developer Relations or folks who do DevRel-related work like conference speaking, but this can actually work well for various roles. Here are a few:
- Developers demoing completed features to their team. My husband is a developer, and he's expressed that building the slide deck is time-consuming just to show off a feature he built to his team.
- Hackathon participants demoing their project to judges. Presentation decks often get neglected because everyone is focused on building the actual project during a small window of time.
- Solutions engineers or sales engineers preparing customer demos. A lot of time goes into building out the demo environment itself, so having help turning that work into a clear deck can save a lot of time.
- Workshop instructors or developer educators teaching technical material. It can be useful to turn the work captured while building the demo or sample app into slides that explain the flow, architecture, or key takeaways.
- Engineering managers or tech leads giving project updates. Sometimes the hard part is not the work itself, but summarizing what happened clearly enough for leadership or cross-functional teams.
- Founders or indie hackers pitching what they built. When you are moving quickly, the last thing you want is to spend hours making slides after already doing the hard part of building the product.
I don’t believe in automating things that deserve a human touch, but I do believe in automating things so I can spend more time with humans. The slides skill has been great for me, but adding Entire to this workflow has made it even easier for me to do that.
Much of my previous work with GitHub and Block (goose) was focused on using agents to build faster. Recently joining the team at Entire has pushed me to think more about the next layer: making agentic work durable and accountable.
Building fast with agents is fun, but in practice, I also need to be able to understand what happened, pick work back up later, explain it to other people, and turn it into something useful beyond the moment it was created. I’ll be sharing more of my agent-native workflows as I continue experimenting.
If you want to learn more about Entire, check out our:
And follow me!
