Presentation Reliability Via Constrained Format And Recovery

Issue 56 Edition 2026-02-25 8 min read

General

Sources: 1 • Confidence: Medium • Updated: 2026-04-13 03:43

Key takeaways

The author sometimes presents by opening a browser window with one tab per web page and advancing through the tabs.
The author delivered the talk using the new macOS app he built in approximately 45 minutes the night before.
Present gained a remote-control feature implemented as a web server listening on 0.0.0.0:9123 that serves a mobile-friendly page with left/right buttons and a start/stop presentation toggle.
The remote control uses GET requests (e.g., /next and /prev) to trigger state changes, which the author considered a CSRF vulnerability but acceptable for this application.
He extended the project beyond the initial app to add remote control via his phone.

The author sometimes presents by opening a browser window with one tab per web page and advancing through the tabs.
Present models a talk as an ordered sequence of URLs that can be added, removed, and reordered via a sidebar.
Present includes a play mode activated from a menu or Cmd+Shift+P that enters full screen, uses left/right arrow keys for navigation, supports font size adjustments and page scrolling, and exits with Escape.
Present automatically saves URLs on every change so that a crash allows the presentation state to be restored on restart.
Present can export and import presentations as a .txt file containing a newline-delimited list of URLs.
The initial specification for Present was a SwiftUI app where each slide is a URL, with an editor view showing a webview on the right and URL list management on the left, plus a full-screen play mode navigated by left/right arrow keys.

The author delivered the talk using the new macOS app he built in approximately 45 minutes the night before.
The app is named Present, is built with Swift and SwiftUI, and is 355KB in size (76KB compressed).
The author built a custom macOS presentation app using vibe coding the night before the talk.
The author concluded that Swift was the right choice for building a full-screen macOS app embedding web content with network control and found the resulting code simple and sufficient.
The author expects to build small personal macOS apps in the future and reported no longer being afraid of Swift after this project.

Present gained a remote-control feature implemented as a web server listening on 0.0.0.0:9123 that serves a mobile-friendly page with left/right buttons and a start/stop presentation toggle.
After iterative prompting, the remote interface included a slide indicator, previous/next buttons, a large Start button, and font size adjustment controls.
The remote interface added a touch-enabled thin scroll bar that scrolls the currently visible web page up and down on the presentation screen by sliding a finger.
Using Tailscale on both laptop and phone allowed the phone to reach the presentation control server via a Tailscale IP from anywhere without relying on venue Wi‑Fi connectivity between devices.
The author described the touch scroll feature as clunky but sufficient for pages where key content initially loads below the fold.

The remote control uses GET requests (e.g., /next and /prev) to trigger state changes, which the author considered a CSRF vulnerability but acceptable for this application.
The author used a pattern of asking the model for a linear walkthrough of the entire codebase and documented this as a "Linear walkthroughs" pattern in an Agentic Engineering Patterns guide.
Claude Code implemented the remote-control web server using raw socket programming without a library, including a minimal HTTP parser for routing.
The author stated that AI-assisted results like this do not make native Mac developers obsolete, and that prior technical setup and knowledge still mattered.
The author pushed the code to GitHub with a prominent disclaimer that it was vibe coded and only promised to work on the author's machine, and the author later decided to inspect the code.

The remote control uses GET requests (e.g., /next and /prev) to trigger state changes, which the author considered a CSRF vulnerability but acceptable for this application.
He extended the project beyond the initial app to add remote control via his phone.

Does Present reliably build and run on machines other than the author’s (different macOS versions, security settings, network environments)?
What security controls (if any) exist on the remote-control endpoints (authentication, origin checks, binding restrictions), especially given binding to 0.0.0.0 and Tailscale reachability?
How robust and correct is the hand-rolled HTTP parsing and routing under malformed or unexpected requests?
What is the exact persistence model for autosave and crash recovery (file location, atomicity, corruption handling, ordering guarantees)?
How well does the URL-as-slide model work in practice for web pages with authentication, dynamic content, offline needs, or network latency during a talk?

Growing niche demand for reliability-focused presentation tooling that reduces browser crash risk via constrained URL decks, autosave, and recovery, suggesting opportunities for lightweight macOS productivity utilities and adjacent workflows.
Continued pull for overlay networking use cases in live environments, where Tailscale-style connectivity enables simple cross-device control surfaces without venue network dependence.
Rising feasibility of rapid, AI-assisted native macOS utility development may increase the volume of small internal tools and indie apps, expanding demand for developer tooling, code review practices, and lightweight distribution patterns.

Evidence that the app builds and runs reliably across macOS versions and varied security and network settings, with reproducible export import and stable crash recovery behavior.
Remote control hardened enough for real-world use, such as authentication, safer endpoint design, binding restrictions, and robust request handling while still remaining simple to operate.
Repeated adoption pattern of embedding web-based control surfaces for desktop apps, with consistent cross-venue connectivity enabled by overlay networking rather than custom mobile apps.

Persistent works-on-my-machine outcomes, brittle crash recovery, or failure under different macOS configurations, undermining portability and the reliability value proposition.
Security incidents or unacceptable risk perception stemming from network-reachable state-changing GET endpoints, weak parsing, or exposure from binding to all interfaces.
URL-as-slide model breaks down in practice due to authentication walls, dynamic content, offline needs, or latency, making the approach unreliable during real talks.