100 Apps, €0?

There are now people trying to build 100 apps in 100 days. Sometimes it is one app every weekday. Sometimes it is 100 apps before a temporary AI subscription expires. Sometimes the apps go to TestFlight, sometimes they are uploaded to the App Store, and sometimes they seem to exist mainly as a screen recording showing that the button worked.

I keep getting stuck on the number.

One hundred apps sounds enormous. It sounds like an industrial achievement. Even a few years ago, someone saying they had built 100 apps would have implied a company, a team, years of work, probably a support department, and a frightening collection of Apple certificates that were about to expire.

Now it can mean that one person spent a few weeks repeatedly asking an AI coding agent to make small utilities.

This is not necessarily fake. The apps may compile. They may run on an iPhone. They may have onboarding, icons, subscriptions and polished screenshots. Some of them may even be useful.

But are they products?

An app used to be a fairly reliable unit of effort. It was difficult enough to make one that the finished object contained evidence of the work behind it. Someone had made decisions, written code, handled edge cases, designed the screens, connected the services, tested the result and eventually fought through App Store submission.

The fact that an app existed implied commitment.

AI has broken that relationship.

A working application can now be generated before anyone has established whether the idea deserves to exist. The code can arrive before the conviction. You can have the interface before you understand the user. You can create a subscription screen before discovering what anyone would subscribe to.

The challenge says: look, I made 100 apps.

The more uncomfortable question is: did anyone want one?

That is where I started imagining the opposite counter for these projects. Not apps built, but euros earned. One hundred apps, €0?

I do not mean this as an easy insult. Revenue is not the only form of value. Building 100 small apps could be an excellent way to learn Swift, understand AI coding agents, test App Store processes or develop a library of reusable components. The person might gain followers, clients, course customers or job opportunities. The apps may function as content, portfolio pieces or public research.

In that case, the apps are doing work. Just not necessarily the work suggested by calling them products.

The challenge may actually be a media format disguised as software development.

Choose a simple idea. Ask the model to build it. Record the screen. Reveal the result. Add 37/100 to the post. Repeat tomorrow.

The audience receives a small miracle every day. A sentence becomes software. Something that previously required a team appears during a lunch break. The growing number gives the series a narrative, even if the individual apps have no users. App 38 matters because it follows app 37, not because somebody needed app 38.

This makes the challenge closer to daily drawing than startup building.

An illustrator can make 100 sketches without claiming to have created 100 visual identities. A filmmaker can make 100 camera tests without claiming to have released 100 films. A product designer can create 100 interface explorations without needing each one to become a company.

Software has rarely been treated this way because software was too expensive to produce. Even a rough interactive experiment required enough effort that people wanted to justify it as a product.

Now the experiment can function.

That is genuinely new.

Maybe the mistake is not that these people call their outputs apps. Maybe the mistake is that the rest of us still hear the word app and imagine a durable product.

What counts as an app now?

Is it an Xcode project that compiles? Something installed on your phone? A TestFlight build? An App Store listing? Something with ten users? Something with paying users? Something the creator will still maintain after Apple changes an API next year?

These used to feel like stages of one continuous process. AI has pulled them far apart.

The first stage may take fifteen minutes. The last stage may still never happen.

I recently ran into a strange version of this while trying to automate the creation of an iOS app. The coding agent could produce the application, edit the project and reason through complicated technical problems. But the workflow stopped at App Store Connect because Apple's Create New App control opened a popup instead of having a normal page with a stable URL.

The AI could create an app, but it could not click the popup.

That sounds like a minor interface problem, but it captures the whole shift. Producing the software is becoming easier than navigating the institution around the software.

The hard part moves into the places we used to consider administrative details: certificates, permissions, screenshots, privacy declarations, review rules, support messages, payments, distribution and the decision to keep caring after launch.

The app is easy. Responsibility is hard.

A portfolio of 100 generated apps does not only contain 100 opportunities. It contains 100 future obligations. Every app can break. Every external API can change. Every subscription can trigger refund requests. Every privacy policy can become inaccurate. Every iOS release can introduce another incompatibility.

The impressive number can reverse direction very quickly.

At the beginning, 100 apps means abundance. Later, it may mean 100 neglected codebases.

This is why I am not sure the correct business model is to generate more apps. When production becomes nearly free, production stops being the scarce part. The scarce part becomes judgment.

Which idea should become more than a prototype?

Which strange response from the first five users reveals a real problem?

Which app should be deleted rather than polished?

Which one deserves another month?

The builders who become good at those decisions may use AI to create hundreds of experiments, but they probably will not operate hundreds of products. They will treat the generated apps as drafts and select a small number to develop further.

The challenge could therefore be useful in a way its title does not fully explain. It is not proving that one person can run 100 software businesses. It is proving that software can now be used to think.

Instead of describing an idea in a document, you can experience it. Instead of arguing whether an interaction will work, you can generate it and press the button. Instead of spending three months on an MVP, you can make several competing versions and discover that all of them are wrong.

That sounds less spectacular than 100 apps, but it may be the more important capability.

The danger is that the generated object looks so finished that we stop treating it as a question.

It has an icon. It has gradients. It has onboarding. It has a paywall. It is sitting on a phone. Every visible signal says product, even when the underlying idea has received almost no contact with reality.

AI makes the draft look final.

That may be the central design problem of this period. We are producing convincing objects before we have earned conviction about them.

The result is a new kind of software abundance where making another thing is easier than understanding the previous thing. A builder can respond to uncertainty by generating app 47 instead of examining why nobody returned to app 12.

The counter keeps moving. The work feels productive. The portfolio grows.

The revenue counter stays at zero.

Maybe one of the 100 apps will eventually become valuable. That is the lottery logic behind the whole system: generate widely, observe what gets attention and invest in the winner. It could work. Mobile games, publishing and consumer products have used variations of this approach for years.

But there is still a difference between increasing the number of experiments and increasing the probability of learning from them.

One hundred apps with no users may teach less than one awkward app watched closely by ten people.

The next interesting challenge would not be 100 apps in 100 days. It would be one app redesigned 100 times after contact with reality. One hundred conversations. One hundred observed failures. One hundred reasons someone closed the app, misunderstood it or decided it was not worth €2.99.

That number would be harder to display in a short video.

It might also be closer to building a product.

Connected reading

• The Prototype Has Become Too Cheap to Trust
• Software for One Afternoon
• The Last Obstacle Was a Popup
• The Coding Assistant Is Becoming the Development System
• The End of the Software Request

AI authorship note

This essay began with Kris Haamer investigating people attempting to build 100 AI-assisted apps, asking how many actually finished, and choosing the title 100 Apps, €0? AI supported the public-source research, comparison of prototypes, TestFlight builds and App Store releases, drafting, editing and publishing workflow. Kris identified the central argument that a working app is no longer reliable evidence of a product and approved the article for publication.