If you treat “what iOS app development tools are” as a list, it’s easy to write: Xcode, VSCode, Git, Firebase… But in real development, these tools are used step by step as development progresses.

Suppose you want to make a simple app from scratch. At which stages will you use which tools?

First choose a place to write code when taking on a requirement

After receiving the requirement, the first step is to write code.

Here you encounter the first choice:

  • Use a full IDE (e.g., Xcode)
  • Use a lightweight editor (e.g., VSCode)

If you only write Swift code, VSCode can handle basic tasks like syntax highlighting and simple autocompletion. But once project structure and execution are involved, more complete tool support is needed.

Some developers choose an environment that “can write and run” at this step, considering the subsequent steps together.

For example, an iOS development tool like Kuaixie itself includes code editing capabilities (based on the VSCode architecture) and also has subsequent compilation and execution capabilities.
Create project

Project structure becomes important as code takes shape

After writing to a certain extent, you will find that code cannot just be scattered files; it needs to be placed in a complete project.

At this point, the tool needs to provide:

  • Project directory structure
  • Entry files
  • Basic configuration

Xcode automatically generates these.

Some new development tools also provide similar capabilities, such as directly generating a standard structure when creating a project, so that the code can be recognized by the build system.

The key here is whether the code already has the conditions to be built.

Compilation tools must be involved when you first want to run the app

When the code reaches a level where it can display a UI, you will want to run it.

This involves compilation:

  • Swift / Objective-C compilation
  • Application building
  • Executable generation

In the traditional workflow, this part completely relies on Xcode.

But there are tools that choose to embed compilation capabilities. For example, Kuaixie provides its own compilation tool suite, completing the build process within the IDE.

The developer’s operation becomes click run → IDE executes compilation → app is generated.

Device debugging becomes a core part when you need to verify functionality

After code compilation, you need to run it on a device.

This involves a set of specific actions:

  • Identify the iPhone
  • Install the app
  • Launch the app
  • View the running effect

If this step is not smooth, it will directly affect development efficiency.

For example, when adjusting UI, every layout change requires re-running the app. If this process takes a long time, it can interrupt your flow.

Some tools make running on a device more direct. For instance, Kuaixie can build and install the app directly after connecting the device, without additional exporting or tool switching.
Device

Multiple technology stacks appear as projects become complex

As the project grows, different types of code appear:

  • New Swift modules
  • Old Objective-C code
  • Introduced Flutter pages

At this point, the requirements for development tools change: they must not only support one language but also handle different project types.

Switching between multiple tools increases context-switching costs.

Some IDEs begin to support unified management of multiple project types, for example, handling Swift, Objective-C, and Flutter projects in one environment.

Build tools reappear when preparing for testing

When the feature is complete, the app needs to be handed over to testers.

This step involves:

  • Building the app
  • Generating installation files
  • Providing distribution methods

In Xcode, this step is done through the Archive and export process.

In some integrated tools, the installation package can be generated directly through the build function.

Kuaixie provides a one-click build capability, generating installation files for testing or distribution.
Build

When breaking down development tasks, it’s essentially that different tools solve different problems, and some tools try to solve these problems together.