comments (10)

  • One down-side to this is that it does require you to run the agent on your Mac instead of in a Sandbox. I do this too and there are lots of problems I can't solve in a sandbox. I know a lot of you are throwing your hands up at the years of security practices we're throwing out the window when we do that.

    The fact that xAI uploaded someone's home directory, including their SSH keys, is giving me serious pause at my choices here.

    Generally, I don't worry about my machine being "blown up". I don't have a TON of unreproducible stuff on my machine. Everything is backed up, committed to git, and the like. I can restore most of it in a couple hours.

    That said, I really, really don't want my .SSH directory sent to an AI agent and it's silly to prompt your way around that. You need to block it at the system level. I'm considering a separate user and then 700 permissions on my home directory.

    I feel like we're back to 1990's security here. The double-edged sword is that it's helping us get things done at a pace like never before.

    I'm not throwing shade here, I'm among the guilty.

    codazoda

  • I've been building and testing my iOS app just for fun via Linux only.

    Surprisingly, it's very easy. This works like a charm: https://github.com/xtool-org/xtool

    You do not need to upload to TestFlight or the App Store; you can just install the app locally to your iPhone via usb -- even from Linux!

    When in doubt, just ask your coding agent of choice to help you create and upload a Hello World iOS app. It's really easy.

    kxxx

  • If it's okay to mention my own complementary open source project, Axiom¹ does a good job of helping coding harnesses know how to do this effectively for Apple OS development.

    In addition to a deep roster of skills and agencts, Axiom includes several for-LLM tools². xclog, xcprof, xcsym, and xcui are designed to be used by LLMs, and expose capabilities in a token-efficient way. These tools are equally helpful for non-Axiom skills/agents.

    ¹ Axiom: https://charleswiltgen.github.io/Axiom/ ² Axiom CLI tools: https://charleswiltgen.github.io/Axiom/tools/

    CharlesW

  • It's kind of funny to be reading this:

    > I had Claude Code create mine: I told Claude, more or less: I want to archive, Developer ID-sign, notarize, staple, and install this app to /Applications without ever opening Xcode. Write me a script that does the whole chain and fails loudly if any step breaks.

    Even though the text we're reading is Claude talking to us as well :)

    Also it was weird to see the mention of "ask your LLM" at almost every stage in the blog post:

    > point Claude Code or your LLM coding tool of choice to this blog post, and let it figure it out

    > When in doubt, ask your LLM of choice about them and have it help you get set up. It’s the one that’s going to be using Xcode for you anyway.

    > The whole point of using the LLM in the first place is to avoid doing things manually that you don’t want to do.

    > Again, if in doubt, ask Claude Code or your LLM of choice to create this for you.

    > Again, this is why you talk to your LLM, tell it what you want, and have it help build your workflow.

    Tiberium

  • Technically, you are using Xcode.

    Xcode is a [buggy as hell] GUI wrapper for a lot of system-level UNIX utilities and apps [which are generally, not so buggy].

    Using CLI to release apps is a pretty old practice; at least as long as I've been doing it (I released my first Xcode app in 2012).

    ChrisMarshallNY

  • Shameless plug: I've been working on strudel [0], a CLI that uses a lot of the same ideas in this post and allows you to build/sign/notarize Mac (and iOS) apps without touching Xcode. It has a dry run mode so you can see the actual commands being run, which was important to me to have so there's no mystery about what's happening.

    I should blog about more this, but I also went to some effort to add support free iOS provisioning with just an Apple ID (using internal APIs); and creating a nice DMGs for macOS app distribution (reverse engineered .DS_store files for this). And there's also a built-in command to install skills for coding agents, which was fun.

    This [1] is an example app I built with it, a simple utility to manage macOS file extension handling.

    [0] https://github.com/octavore/strudel

    [1] https://github.com/octavore/tots.app

    octavore

  • Everyone will still need to use Xcode for at least some debugging, no way around that.

    As for the builds, your agent probably already knows how to do a lot of this from the command line, although explicit suggestions can help it build faster for different situations.

    As for XcodeGen, you may find it unnecessary overhead if you're already using Xcode file system synced groups.

    For iOS my biggest suggestion would be to enable App Store Connect skills for your agent (https://github.com/rorkai/App-Store-Connect-CLI).

    With this not only do you not need Xcode all the time, you also don't even need to be near a MacBook.

    Just make changes via Codex on your iPhone, the tell asc to build and upload to TestFlight, download and run the new version, iterate.

    WhitneyLand

  • In my experience, the better long-term choice if you're going to vibe code an app is to use Expo.

    Its basis is React, so the code output quality is much higher than Swift because there is much more React code in LLM training data.

    Everything is in the command line, and debugging is a breeze because it's a web view. But once it's compiled to native iOS, it feels like any other native app.

    Expo + Fastlane = fully automated iOS submission and deployment. I issue one command and see a new version in the App Store.

    mvkel

  • This is cool but also makes me worried about the tendency with llms for all of us to make bespoke solutions rather than building a better community tool or extending an existing tool to solve the problem. fastlane exists to solve exactly this problem in the mobile space.

    mrbombastic

  • I've been using agents to develop Mac and iOS apps for over a year now and I would say this post is bad advice, particularly because the excellent Xcode MCP requires Xcode to be running. The MCP tool gives you faster, better access to a number of functions for which xcodebuild is much slower and much chattier and a number of others (like the #Preview generation and rendering) that aren't possible at all while Xcode is closed. Also, in Xcode 27, the MCP & built-in agents are able to drive simulators with DeviceHub extremely well. (If you haven't been following, DeviceHub replaces Simulator.app and as far as I can tell, it's actually scrutable by agents without relying on hacking at the accessibility APIs with tools like axe.)

    Xcode MCP is not perfect, by any stretch (stupidly, it issues a permission prompt on every single agent launch—something I defeated with a Keyboard Maestro hack to auto-accept it), but Xcode 27 is such a huge leap forward in the ergonomics of vibe coding with Xcode that I've actually stopped dealing with the MCP and (after an afternoon of futzing) have started using the app's own agent UI for driving Codex because that harness better steers the model to take advantage of the tools available.

    All of this redounds to two things: faster feedback and more robust verification. The two things that matter most.

    searls