DEV Community

Howard Le
Howard Le

Posted on

How We Adapted Our Native Mac, iPad & iPhone Planning App for the AI Era (Without Hardwiring an AI API)

TL;DR

  • Rather than hardwiring an embedded chat sidebar or API keys, a traditional native app can adapt to the AI era by flexibly importing understandable intermediate results—WBS text outlines and tabular data.
  • Treating plain indented text and spreadsheet tables on the system clipboard as the interface lets any external AI model feed a native WBS and Gantt engine.
  • Strict leading-space prompt constraints eliminate Markdown formatting noise so a parser can build nested parent-child trees in a single paste.
  • LLMs handle cold-start drafting and whiteboard OCR; deterministic scheduling math (dependencies, working calendars, critical path) stays strictly in the native app.

How Can a Traditional Native App Meet the Demands of the AI Era?

A traditional native app can meet AI-era demands by focusing on flexible import of understandable intermediate results—such as indented WBS text and spreadsheet tables—over the system clipboard. Users gain AI-assisted drafting speed from ChatGPT, Gemini, or Claude while keeping native scheduling independent and free of extra AI fees.

When generative AI arrived, many established desktop apps rushed to embed chat sidebars, manage API proxies, and introduce new AI subscription tiers. While building QuickPlanX for macOS, iPadOS, and iOS, we asked a different question: how can a focused, traditional native app embrace AI-era productivity without sacrificing simplicity or user control?

Our answer rests on a straightforward design principle: we do not directly integrate AI into the application. Instead, we let external AI generate understandable intermediate results—specifically, clean WBS hierarchies and structured table data—and focus the app on flexibly parsing and importing those intermediate formats.

That decoupling delivers three concrete architectural advantages:

  1. Flexibility: Users are not locked into a specific AI vendor—or even forced to use AI at all. Whether an intermediate outline comes from ChatGPT, Claude, Gemini, Copilot, a plain-text editor, or Excel, the app ingests it identically so each person can selectively apply AI wherever it genuinely speeds up their workflow.
  2. Independence: The scheduling application does not depend on what AI models can or cannot do today, how their APIs or pricing evolve tomorrow, or on AI availability itself. If an LLM vendor changes policies or goes down, your planning workflow keeps running unchanged.
  3. Cost Convenience: Because inference stays outside the app boundary, the developer never has to pass token costs on to users or charge extra AI subscription fees.

Instead of owning the inference layer, loose coupling wins: let external models emit structured intermediate artifacts, and let a fast native parser import them via standard system clipboard paste across Mac, iPad, and iPhone—pairing naturally with Apple's Universal Clipboard when you snap a photo or copy an outline on one device and paste on another. QuickPlanX was built by pushing classic native app mechanics—fast multiline text parsing and spreadsheet cell copy-paste—as far as they could go. Because the interface is simply an understandable intermediate format rather than a hardwired AI API, that exact same design works cleanly for both traditional pre-AI workflows (plain-text editors, Excel, Apple Numbers, OPML mind maps) and AI-assisted workflows (LLMs and vision models), with zero lock-in or extra AI fees.


How Do You Prompt an LLM for Deterministic Tree Parsing?

To make LLM output machine-parseable into a work breakdown structure (WBS), forbid Markdown bullets, numbers, and bold formatting, and enforce exactly one leading space per hierarchy level inside a fenced code block. Parsers can then map indentation depth directly to parent-child task nodes in one paste.

Ask a chat model for a project plan with a naive prompt and it almost always returns prose mixed with **Phase 1**, - Subtask, or 1.2.1 numbering. Stripping those tokens manually defeats the point of using AI for speed.

The Minimal 2-Line Constraint

When you only need a fast starting outline, two lines of formatting constraint do the heavy lifting:

Create a work breakdown structure for a residential build.
Output plain text only, using 1 leading space per level for hierarchy, with no bullets or numbers.
Enter fullscreen mode Exit fullscreen mode

That constraint produces a clean hierarchy ready for direct parsing:

Pre-Construction & Permits
 Zoning Review & Permit Filing
 Architectural Sign-off
Site Work & Foundation
 Excavation & Grading
 Pour Concrete Footings
Framing & Rough-ins
 First Floor Framing
Enter fullscreen mode Exit fullscreen mode

The Production 5-Level WBS Prompt Template

For unfamiliar domains or deeper schedules (3 to 5 levels), vague instructions cause models to drift back into Markdown bullets halfway down the response. Encapsulating the output inside a fenced code block with explicit level-by-level space rules keeps indentation deterministic:

Role: Expert Project Manager with long-standing experience in residential construction.

Objective: Develop a detailed project schedule (Work Breakdown Structure - WBS) for a compact residential build.

Project Scope:
- Structure: Two-story family residence
- Area: Approximately 300 square feet (very compact)
- Amenities: Includes a small yard
- Quality: Standard construction quality
- Timeline: Target construction period of approximately four months

Deliverable Requirements:
- Present the project schedule as a multi-level, hierarchical task breakdown.
- Structure the breakdown logically by major construction phases (e.g., Pre-Construction, Site Work, Foundation, Framing, Rough-ins, Finishes, Exterior, Landscaping, Closeout).
- CRUCIAL: Each task or sub-task MUST be indented using 1 leading space per level to define its outline level:
    - Level 1: No leading spaces (e.g., "Phase Name")
    - Level 2: One leading space (e.g., " Major Activity")
    - Level 3: Two leading spaces (e.g., "  Sub-Activity")
    - Level 4: Three leading spaces (e.g., "   Detailed Task")
    - Level 5: Four leading spaces (e.g., "    Specific Step")
- The leading spaces are the ONLY indication of hierarchy. Do not use any bullets, numbers, dashes, asterisks, or any other formatting symbols whatsoever.
- Aim for 3-5 levels of detail where appropriate, focusing on a swift 4-month completion.
- Encapsulate the entire project schedule within a fenced Markdown code block so spacing stays intact.
Enter fullscreen mode Exit fullscreen mode

When that code block hits the clipboard and is pasted into QuickPlanX, leading spaces map straight into parent tasks and nested child branches—no CSV preprocessing or custom import wizard required.


How Can Vision Models Turn Whiteboard Photos into Structured Schedule Columns?

Vision-capable models can extract handwritten task names, start dates, and durations from kickoff whiteboard photos or site notebooks into a clean tabular format. Asking for weekday-only dates aligned to your device's short date format (yyyy/MM/dd) lets you copy rows straight into QuickPlanX's Table View without manual retyping.

In practice, early schedules rarely begin inside a prompt box. They start on a conference-room whiteboard or a field notebook during a site walk.

Passing a photo of those notes to a multimodal model (such as Gemini, ChatGPT, or Claude) with a tight extraction prompt turns handwriting into structured rows:

Fetch the task name, start date and duration from the photo, and output in a table.
Enter fullscreen mode Exit fullscreen mode

Example extracted output:

Task Name Start Date Duration
Site Survey & Boundary Check 2026/09/05 2d
Clear & Grade Ground 2026/09/07 3d
Trenching for Utilities 2026/09/10 4d

If you want an LLM to propose working-day dates for an existing WBS before importing or updating columns, add explicit calendar and locale constraints:

Please help schedule the tasks and present the results in a table with the following requirements:
- Include Task Name, Start, and Finish columns.
- Display Task Names without leading indentations or spaces.
- Start and Finish dates must fall on working days (weekdays only).
- Format dates using the short date format (yyyy/MM/dd) matching my device locale.
Enter fullscreen mode Exit fullscreen mode

Why our walkthrough demos use Gemini + Sheets: Because QuickPlanX supports both bulk indented text and bulk spreadsheet table copy-paste, pairing an LLM with a spreadsheet makes column updates fast. In our own video demonstrations we used Gemini specifically because exporting its generated or photo-extracted tables to Google Sheets takes one click, and copying clean columns from a spreadsheet straight into QuickPlanX's Table View is seamless. Other AI tools such as ChatGPT, Claude, or Copilot should support similar table workflows too—either copied directly or staged through Excel, Numbers, or Google Sheets first.

Engineering detail worth noting: In QuickPlanX's Table View, once your task hierarchy exists, you can batch-paste cells directly from a table or spreadsheet. To prevent mathematical contradictions inside the scheduling engine, batch updates intentionally block overwriting Start, Finish, and Days simultaneously in a single pass—you apply one clean column at a time so duration and dependency calculations stay consistent.


Where Should AI Stop and a Deterministic Scheduling Engine Begin?

LLMs should stop once the initial task hierarchy and rough table columns are drafted. Language models predict plausible durations from training text, not real crew capacity, supplier lead times, or calendar constraints. A deterministic scheduling engine must calculate dependencies, working calendars, and critical-path shifts reliably.

What comes out of a chat window is still a static text artifact. It has no live dependency graph, no working-calendar awareness, and no recalculation when an upstream task slips by three days.

Here is how we drew the architectural boundary between external LLMs and QuickPlanX's native multi-view engine:

Capability External LLM (ChatGPT / Claude / Gemini) QuickPlanX Native Engine (macOS / iPadOS / iOS)
Cold-Start WBS Drafting Generates domain phase checklists in seconds Parses 1-space-per-level text into a live nested tree on paste
Handwritten Note / Whiteboard OCR Extracts task names, dates, and durations into tables Accepts tabular paste directly into Table View columns
Hierarchy Reorganization Requires re-prompting or manual text editing Visual drag-and-drop in Tree View and Column View
Dependencies & Critical Path Text guesses; breaks immediately when one date shifts Real dependency links in Gantt Chart with automatic recalculation
Working Calendars & Constraints Often hallucinates weekends or ignores non-working days Per-task constraints, calendars, and progress in Inspector
AI Cost & Vendor Lock-In Use whatever model or free tier you already have Zero built-in AI subscription or API key required

Once the raw draft lands in QuickPlanX via the clipboard, the workflow shifts across four coordinated views bound to the same data model:

  • Tree View & Column View: Drag branches and adjust indentation as real project scope sharpens.
  • Table View: Bulk-edit dates, durations, resources, and custom fields across rows like a spreadsheet.
  • Gantt Chart: Wire sequential dependencies and see immediately how a delay impacts the critical path.
  • Inspector: Set working calendars, task constraints, and completion progress without leaving your scroll position.

Full Prompt Templates & Live Walkthrough

I documented the complete clipboard-to-Gantt workflow—along with copy-pasteable WBS prompts and short video clips showing both AI outline pasting and handwritten note extraction in action—on the QuickPlanX site:


Disclosure: I'm Howard Le, the developer building QuickPlanX for macOS, iPadOS, and iOS. If you've experimented with using plain-text whitespace protocols or the system clipboard as a lightweight bridge to LLMs in desktop apps, I'd be glad to hear what edge cases you ran into in the comments.

Top comments (0)