I recently published an app on Google Play where 99.9% of the source code was written by AI. It’s not just some "weekend hack job": a native app (Kotlin), over 50 screens, complex animations, multilingual support, an extensible architecture.

I achieved this through a highly detailed specification. Every screen was prototyped by a designer, for every button there was a description of which APIs to call. Was it worth it? Let’s look at the numbers.

Across all iterations, the AI ​​churned out 200,000 lines of code. The average productivity of a developer (myself) is around 2,000–3,000 lines of code per day. 90% of the time went into preparing specifications, and 10% into reviews and adjustments. The actual code generation time was negligible. Over eight months I never once exceeded the $20 budget (the basic Cursor subscription).

Scope of specifications (text files):

  • for the frontend (Kotlin): 290 KB, code size 1.7 MB + 750 KB of layouts

  • for the backend (.NET): 100 KB, code size 500 KB (excluding configs and migrations)

Not only are the specifications 5–10 times shorter than the source code, but they are also more readable. Typical code for a button: 

# 1. General Rules
When calling any API, use the session key and generate a GUID for the transaction_id
If a 401 error occurs navigate to login window

......

# 9. button_build
The button is active if the user has entered text into the building_name field
When the button is clicked call Game.AddBuilding. Use Helper.LoadingButton
If there are no errors open the GameBuilding window

Everything is in one place and highly compact unlike the generated source code. These files are easy to update. The AI ​​locates all related code segments and modifies them correctly. Furthermore, the specifications are largely platform-independent: having the working native Android app I can now use the same "source code" to generate a native iOS version (once I get my hands on a Mac) and, with minor tweaks, a web version. I even shared some of the "source code" between the frontend and backend (parameter validation).

I maintain a separate specification file for each screen and API method. I’ve placed the screen layouts from the designer into a folder for AI as screenshots, alongside the XML files (exported from Figma). I decided against setting up MCP, it seems like overhead to me. There are 100 screens in the Figma project so that would consume a lot of unnecessary tokens and also requires an upgraded Figma license.

The code review took relatively little time. With the specification right in front of you, you already have a mental picture of the desired outcome. So it is simply a matter of comparing the source code against those expectations. The project's modular structure is rigidly defined. The code remains understandable even after six months of development. No degradation was observed but quite the opposite: the more existing code there is, the more accurately new code is generated.

What didn't go well:

  • I tried asking AI to write specifications for me but the results were dismal. It has a poor grasp of business problems and tends to hallucinate a lot of unnecessary details.

  • I also tried to generate large chunks of code without specifications. Any non-standard task that I didn't know how to implement myself invariably failed, such as "Implement a spell-checker that works in two languages ​​simultaneously and underlines errors in red, using standard Android libraries". I burned a lot of tokens and had to delete all the code because it simply didn't work.

  • I tried porting a small part of ffmpeg to .NET, I only needed a single codec. It couldn't handle the task even with the ffmpeg source code available. It just got stuck in an endless loop of trying to fix errors.

What went very well:

  • A custom 10-language keyboard with complex animations. A very concise specification, a massive amount of code and an excellent result. There were issues with handling concurrent button inputs but the AI guided by my prompts identified all the problematic areas and fixed them.

  • A Python script to synchronize data from Excel to MS SQL Server was generated in just five minutes from a single prompt. AI ​​analyzed the structures of both the Excel file and the database on its own and even generated test data with translations into 10 languages.

Developing specifications requires a Product Manager and an Architect, ideally, the same person. Otherwise, welcome to "Agent Swarms," ​​"Skills," MCPs, and other money pits.