An independent developer has demonstrated that large language models can handle tedious, multi-step macOS workflows with surprisingly little prompting. The task in question is archiving app icons, and the results suggest that the gap between what developers will tolerate doing manually and what they will trust an LLM to do continues to shrink.
The Problem and the Manual Workflow
Whenever a new version of macOS ships, the developer behind the macOS icon gallery at blog.jim-nielsen.com faces a repetitive task: archive the new app icons that come with the operating system. The manual process requires finding each app in the Applications folder, opening its Get Info panel, copying the icon, pasting it into Preview, exporting it as a PNG, and naming it using a lowercased, hyphenated convention. For every Apple-supplied app in the system, this is often upwards of 75 icons that need to be processed individually.
The work is not technically demanding, but it is the kind of repetitive, low-cognition task that accumulates. Each icon follows the same sequence of steps, and after the 20th or 30th copy-paste-export cycle, the developer's attention drifts.
Turning the Task Over to an LLM
The developer decided the task was well suited for a large language model. The first prompt was written hastily, and the result was imperfect. The LLM located each app's .icns file and grabbed the 256-by-256 pixel version, then upscaled it to 1024 by 1024 pixels before saving it. That is not acceptable for an icon archive where resolution fidelity matters.
The correction was simple but specific: "Never upscale an image. Always find the biggest one." The developer pointed out that the 1024-pixel version is accessible through the Get Info panel and that the LLM should be able to locate it. On the second attempt, the LLM found the correct image size and delivered the right output.
What Actually Happened
Once the LLM had been corrected, the developer compiled a list of all the apps whose artwork needed archiving and handed it off. The LLM processed the entire list autonomously. The final result was 76 app icons found, extracted, and saved in far less time than the manual workflow would have required.
The task is not novel in any technical sense. No custom model was trained, no complex pipeline was built, and no API integration was required beyond the LLM's existing tool access. The developer simply described the workflow, corrected one behavioral failure, and let the system run.
The Larger Pattern
This kind of anecdote is becoming common enough that it barely registers as news on its own. What makes this one useful is the specific failure mode: the LLM chose a smaller image and upscaled it rather than finding the larger native version. The fix was a single instruction, not a prompt rewrite or a pipeline rearchitecture. The model understood the task well enough once it knew the constraint.
For developers evaluating where LLMs can fit into their own workflows, the pattern is instructive. Tasks with clear, repeatable steps and a well-defined success criterion are strong candidates. Tasks that require visual judgment or fine-grained preference may need a correction cycle before they work reliably. And the cost of that correction, measured in a single conversational exchange, is dramatically lower than the cost of doing 76 manual operations.