AI-Assisted Mac App Development: Beyond Prompt Engineering

Mblarsen shipped a macOS App Store app, EqualEase, by building a structured AI development system. This approach prioritized architectural 'rails' over individual prompt optimization, demonstrating a repeatable playbook.

Mblarsen shipped EqualEase, a macOS App Store app, with substantial AI assistance. This project demonstrated that the efficacy of AI in development workflows depends less on prompt engineering and more on the scaffolding that surrounds the AI models. The core insight was that a structured system, not isolated prompts, enabled the successful delivery of a complex application.

The biggest lesson was that the surrounding system mattered more than any single model response.

Pre-implementation planning with ExecPlan

Mblarsen initiated the EqualEase project with a "living ExecPlan" maintained directly within the repository. This document served as a dynamic blueprint, forcing an outcome-oriented approach from the outset. It meticulously detailed anticipated user capabilities, identified potential technical and product risks, outlined validation methodologies, tracked learned lessons, and recorded key decision changes. This structured planning phase was not merely bureaucratic; it actively prevented the application from evolving into a collection of disconnected, AI-generated features. A critical example cited was the early identification of a core technical risk: not the ability of AI to construct a SwiftUI UI, but the more fundamental challenge of safely routing system audio within the stringent permissions and entitlements of a sandboxed Mac App Store application. This foresight guided subsequent development and AI agent tasks, ensuring efforts addressed the most significant hurdles first.

Autonomous agents within defined constraints

The development process employed AI agents capable of autonomous operation, but strictly within predefined constraints. These were not simple “change this function” prompts. Instead, agents received end-to-end tasks complete with contextual information, clear acceptance criteria, and explicit validation commands. Their operational toolkit included direct access to Xcode, enabling them to run builds and tests, inspect the application's runtime behavior, update OpenSpec tasks, modify the central ExecPlan, and commit code changes. For UI-specific work, agents were further equipped with tools to interact with the live application, including screenshot capabilities, mouse and keyboard automation, and direct Xcode access. This comprehensive setup transformed the AI's role from a mere code generator into a system capable of completing verifiable, self-contained development slices, ensuring each contribution met specific functional and quality benchmarks.

Multi-agent collaboration via pi-link and /tree

Mblarsen developed a nuanced multi-agent collaboration strategy that evolved dynamically. The workflow typically involved one primary agent maintaining the core development thread. Additional agents were introduced as needed, either for specialized expertise or to explore parallel solution paths. A key enabler for this was the pi-link extension, which connected agents within a tmux session. This allowed mblarsen to directly intervene and steer conversations with either the main implementation agent or a specialized agent, such as one focused on UI/UX critique. The founder noted this setup felt less like a monolithic chat and more like managing a small, adaptable team. This paired effectively with Pi's tree-like session history, accessed via /tree. This feature allowed mblarsen to branch off to explore specific topics or build steps, summarize findings, and then return to an earlier point in the main session with enriched context, avoiding the constant need to compact a single, lengthy conversation. This iterative process of “explore, summarize, return, repeat” proved highly valuable for navigating complex development challenges.

Visual feedback loops for UI refinement

A significant portion of critical fixes and refinements, particularly concerning the user interface, relied on the AI agents' ability to interpret and reason from actual visual evidence. Mblarsen provided concrete examples from the project's documentation trail where visual feedback was indispensable. These included correcting instances where the menu-bar panel opened underneath a temporarily visible menu bar with auto-hide enabled, ensuring the panel pointer was correctly positioned outside the orange body, resolving visual clashes between the preset selector and the orange header in dark mode, adjusting the app icon to prevent it from appearing oversized in the Dock by adding transparent safe-area padding, and eliminating an unwanted dark border around the iOS Home Screen icon for the local remote. These are issues that are inherently difficult to diagnose and resolve through code review or textual descriptions alone. To facilitate this, agents were given access to screenshots, the Shottr utility, general visual references, and pi-sketch (@ogulcancelik/pi-sketch), enabling them to draw and explain visual discrepancies directly.

Architectural AI work beyond additive features

Beyond generating new features, the most impactful contributions from the AI agents were often architectural. Mblarsen highlighted that some of the most valuable tasks involved refactoring existing code to improve the application's overall understandability and maintainability. This included streamlining code structures, clarifying dependencies, and enhancing the modularity of components. Such architectural improvements, driven by AI, ensured that the growing codebase remained coherent and manageable, preventing it from becoming an unwieldy “pile of generated features.” This demonstrated a shift in AI utility from mere feature addition to core structural enhancement, a less obvious but ultimately more profound application of AI in development.

WHAT WE'D CHANGE

The described workflow, while effective for mblarsen, exhibits specific dependencies that limit its direct portability. The reliance on the Pi agent ecosystem, including tools like pi-link for multi-agent communication and /tree for session management, means that founders without access to or familiarity with these particular platforms would face a significant barrier to entry. Replicating the seamless multi-agent collaboration and contextual branching outside of this environment would likely require substantial custom development or the integration of distinct, potentially complex AI orchestration frameworks. This introduces an overhead that might negate the efficiency gains for teams not already invested in the Pi stack.

Furthermore, the success of the “living ExecPlan” is intrinsically linked to the founder's rigorous adherence and continuous oversight. While AI agents can update the plan, its strategic value diminishes rapidly if it becomes a passive repository of generated tasks rather than an actively managed, outcome-oriented guide. The founder's initial discipline in defining the plan's structure and consistently reviewing its contents appears to be a critical, non-AI-driven component of this playbook. Without a similar commitment to disciplined planning and human-led strategic direction, the AI-driven updates to the ExecPlan could lead to a well-documented but ultimately misdirected development effort.

The specific technical challenges highlighted, such as navigating system audio routing and sandboxing within a macOS App Store context, are highly domain-specific. While the principle of identifying and addressing core technical risks early is universal, the nature of those risks will vary wildly across different application types and platforms. Founders building web services, mobile apps, or embedded systems will encounter entirely different foundational hurdles. The playbook's emphasis on visual feedback, while crucial for UI-heavy applications like EqualEase, might be less central for backend services or command-line tools, requiring adaptation to different forms of verifiable output and feedback mechanisms.

Mblarsen's approach to developing EqualEase demonstrates that AI's transformative potential in software development is realized through systematic integration, not isolated prompts. The “rails” of structured planning, constrained autonomy, multi-agent coordination, and visual validation create a robust framework. This framework allows AI to move beyond code generation to become a partner in architectural decisions and iterative refinement. Founders seeking to harness AI effectively should prioritize building similar comprehensive systems, focusing on the surrounding infrastructure as much as the models themselves.

Pull quote: “The biggest lesson was that the surrounding system mattered more than any single model response.”