The development of an iOS app with generative AI

Will developers soon be made redundant by generative AI? Opinions on this vary widely. From ‘90% of all developers will be replaced by AI’ to ‘AI reduces the productivity of programmers’ [1], pretty much everything is on the table.

I had previously used large language models (LLMs) to convert business processes from various sources – Excel spreadsheets, text descriptions, even photos – into BPMN models. And it worked surprisingly well [2].

So I asked myself: Is it possible to develop an iOS app and publish it in the App Store without any prior knowledge, using only AI?

No sooner said than done: I downloaded Xcode, typed my idea into a chat and got started.

What could possibly go wrong?

The easy way to create the first rudimentary version of the iOS app

I should start by saying that I used to develop software myself in the dim and distant past. Back then, Git was still called CVS, a Pentium 60 was all the rage, and programming was done in C. I switched to consulting 25 years ago and haven’t written a line of code since. I knew only one thing about the programming language in the Apple universe: it’s called Swift. That was about it.

The start was promising. After I typed my request into the LLM of my choice (Claude [3] from Anthropic – more on that later), the AI spit out 317 lines of code. At first, it couldn’t be compiled, but if you copy the faulty sections back into the chat along with the error message, the AI apologises (which is sometimes really funny) and then delivers a revised version. A short time later, I had a rudimentary but functional iOS app in my hands.

My ambition was piqued. Now just add a few more features and off it goes to the App Store!

The source code grows, and so does the list of problems

The source code grew rapidly with each request. Unfortunately, so did the problems and error messages. It often happened that new code sections generated so many errors that I spent more and more time debugging. After some research, I found out that Apple had changed its frameworks some time ago (from UIKit to SwiftUI) and introduced several new features in version 6 of Swift.

In most cases, the AI generated code according to the old standards, unless you explicitly requested otherwise. This is often a problem with generative AI: it usually knows old concepts better because there is more training data available for them.

Another problem was the somewhat unstructured nature of my requirements, which were often misunderstood by the AI.

I realised that without knowledge of the concepts and without understanding the generated code, I would not get anywhere. So I worked my way through an 800-page tome on Swift [4] and started all over again.

Choosing the right AI for complex requirements

The choice of LLM is crucial. In my case, Claude 4 with ‘extended reasoning’ has proven to be particularly powerful. I mostly work with Claude 4 Sonnet, but for very complex requirements I occasionally use Claude 4 Opus. Claude 4’s ability to correctly execute complex tasks was particularly impressive.

Gemini 2.5 Pro also delivered usable results, but ChatGPT o3 and DeepSeek didn’t really convince me.

However, this applies specifically to software development with Swift – the situation may be completely different for other programming languages or task areas.

One of the biggest project risks is unclear, incomplete or constantly changing requirements. This is no different when working with AI and goes beyond pure prompt engineering. I have adopted the following approach:

• More complex queries are first written in an editor and only copied into the chat after they have been checked.
• I put myself in the role of a subject matter expert and try to formulate a request in a clear, structured, complete and consistent manner, just as I would in a project with ‘real’ developers.

I also provide as much context as possible. This can include examples, sketches or snapshots, but also websites or manuals.

One step at a time

It would be naive to believe that you can describe a complex app to AI in a single prompt, wait a moment and then receive a finished result. This approach may work for simple examples or a snake game, but it quickly reaches its limits.

Working with AI is a dialogue:

• You formulate a request,
• check the result,
• refine the requirements and
• provide feedback if something does not work or cannot be compiled.

I focus on exactly one function or component at a time. Once this has been successfully implemented, tested and versioned, I start a new conversation to develop the next building block.

When testing my app, the AI was only able to help me to a limited extent. It generated unit tests for some functions, but you have to check for yourself whether the app actually runs smoothly on different iOS versions and different devices. Perhaps it’s different with other apps, but in my case, the tests were almost as time-consuming as writing the source code.

Further insights gained during the development of an iOS app with generative AI

You can easily ask questions in German, but subjectively speaking, the quality of the answers in English often seems to be better. I can’t prove this, but my impression from many sessions is clear: the LLMs simply feel more comfortable in English.

Another thing that stands out is that the quality of the responses often declines in longer chats. In some cases, Claude descended into creative over-complexity and suddenly delivered hundreds of lines of code without getting any closer to the actual solution. In such situations, it was often more effective to leave the previous conversation behind and start a new one.

It is very important to clearly communicate the desired context and your own expectations to the AI. In Claude, you can create a project and connect it to GitHub so that the AI can access the current source code at any time.

In addition, project-related instructions and guidelines, known as custom instructions, can be defined and applied to all chats. If these are well formulated, they can improve the quality of the results in the long term.

The following custom instructions have proven particularly useful for my project:

You are a highly experienced and proficient AI developer specialized in building applications for macOS, iOS, and iPadOS using the latest Apple technologies. New functions should be developed with Swift 6, SwiftUI, and the most current features available in the latest version of Xcode (including beta or preview releases if applicable). Remain existing Code unchanged whenever it’s possible.

Think step by step and check your suggestions. Break down larger tasks into smaller subtasks and ask questions if necessary.

Your Objective:

Develop solutions as a senior Apple developer would: modern, efficient, scalable, and in full alignment with Apple’s platform conventions and design principles. Always consider best practices in architecture, performance, accessibility, energy efficiency, localization, modularity, and cross-platform development.

Your responsibilities and capabilities include:

1. Design adaptive SwiftUI interfaces that follow Apple’s Human Interface Guidelines and work seamlessly across device families (iPhone, iPad, Mac).
2. Write cross-platform Swift code that gracefully differentiates behavior or UI per platform.
3. Write clean, well-documented, and maintainable code, preferably organized using Swift Package Manager.

Code Style Guidelines:

• Always use modern Swift 6 syntax for new features.
• Favor a SwiftUI-first approach.
• Avoid UIKit or AppKit unless explicitly required.
• Write code that is testable, modular, and ready for production.
• Clearly explain technical decisions with expert-level reasoning, while remaining concise and practical.

Conclusion

I don’t believe that AI will replace developers in the foreseeable future. Anyone who doesn’t understand the basic concepts, has no idea about software architecture and can’t evaluate the results will fail when faced with more complex requirements.

But I am convinced that developers can work much more productively with AI, provided the right conditions are in place. This includes choosing the right model for the task at hand and, above all, learning how to interact effectively with AI.

At least, that’s where we stand in mid-2025. Given the rapid pace of development, things could look very different in a few years – or even months.

Notes (partly in German):

Would you like to know the outcome of the project? Then take a look at applicay.com.

[1] Joel Becker, Nate Rush, Elizabeth Barnes, David Rein: Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity
[2] SAP Community: Generate Process Models with GenAI
[3] Thomas Sillman (Hanser): Das Swift Handbuch
[4] Anthrophic: Meet Claude, your thinking partner

Here you will find an article about WebApps in the address bar of the browser.

And here is an article about the pros and cons of the usage of ChatGPT in software development.

Would you like to discuss this topic as an opinion leader? Then feel free to share this post on social media or within your network.