I Built an Android App in 4 Days With Zero Android Experience — Using Claude Code and a Two-Layer AI Protocol

Source: Dev.to

Background

I’m a control‑systems engineer, not a programmer. For 15 years I’ve designed control logic for motorcycle ECUs—traction control, quickshifters, drive‑by‑wire systems—for European sport‑bike manufacturers. My day‑to‑day work involves drawing flowcharts and writing specifications that software engineers turn into code. I can read C, but I don’t write it professionally; my strongest language is VBA.

Kotlin, Jetpack Compose, Gradle—completely foreign territory.

I needed a solution for a personal problem: I hold a life‑insurance product with an investment component. The provider’s online portal shows almost nothing useful—no charts, no trend visualization, no way to compare performance against a benchmark index. The product had been slowly declining in value, and after the new year it dropped several steps further. I needed to see the actual data, not just a feeling.

No existing app could do this, so I decided to build one.

Early AI Attempts

Initially I tried a single‑workflow AI approach: describe what I wanted, let the AI suggest an approach, approve it, and have it implement everything. The result was code that appeared to work but was riddled with shallow fixes, misunderstood requirements, and recurring bugs. The AI was building on foundations it didn’t fully understand, and I couldn’t catch the issues because I was trusting its judgment on implementation details outside my expertise.

That experience taught me a key lesson: AI needs the same separation of concerns that human engineering teams use.

Two‑Layer AI Protocol

Design AI – The Architect

• Handles requirements analysis and system design.
• Creates structured implementation instructions as Markdown files.
• Never touches code.

Implementation AI (Claude Code) – The Builder

• Receives specific, scoped instructions and executes them.
• Writes code, runs builds, reports results.
• Does not make design decisions.

Me – The Bridge

• Relays instructions, tests on real devices, makes judgment calls, and handles Git.
• Investigates before fixing: when something breaks, the Implementation AI reports the issue; the Design AI and I analyze the findings and decide on the approach before any new code is written.

Critical rule: Investigate before you fix. No blind thrashing.

Project Timeline

Day 1 – Setup & Decomposition

• Chose tech stack: Kotlin + Jetpack Compose.
• Decomposed the project into 7 steps.
• Built the first version on an emulator by the end of the day.

Day 2 – Data Layer

• Implemented the data layer.
• Hit a wall: Room (Android’s database library) was incompatible with AGP 9.0 due to kapt deprecation.
• Decision (within 2 hours): drop Room, use SharedPreferences + Gson. Not elegant, but functional for MVP scope.
• Time lost: ~2 hours.

Day 3 – Scraping & Normalization

• Implemented HTML scraping for the insurance provider’s data.
• Added CSV parsing for the benchmark index.
• Performed date‑based normalization with inner joins.
• Built the detection logic: 4 judgment types and a 10‑level ranking system.

Day 4 – UI & Background Work

• Integrated MPAndroidChart for charting.
• Added settings screen, navigation, app icon.
• Configured WorkManager for background scheduling with exponential backoff.
• Implemented push notifications.
• MVP complete.

Artifacts Produced

• 53 structured instruction files.
• 7 step‑chat documents.
• 1 assembly chat orchestrating everything.

Lessons Learned

• Library Compatibility: Room + kapt on AGP 9.0 was an unexpected blocker. The Design AI and I discussed trade‑offs and accepted SharedPreferences for the MVP.
• Tool Proficiency Check: Started with Vico for charting, switched to MPAndroidChart when the Implementation AI couldn’t produce working code. Verify the AI’s actual proficiency with a library before committing.
• Failure Containment: The two‑layer protocol kept failures from derailing the project. Investigate first, discuss options, then implement the fix.
• Reusable Protocol: I previously used the same protocol for Bridgiron—a desktop development support tool. The discipline works across domains and tech stacks.

Conclusion

I’ve been using Claude Code for about four weeks and have systematized a reusable protocol for AI‑augmented development. If you’re an experienced engineer in one domain wondering whether AI can make you productive in an unfamiliar stack: yes, but only if you treat the AI as a system to be engineered, not just a prompt to be written.

Control systems engineer, 15 years in motorcycle ECU development. Currently exploring AI‑augmented development workflows and documenting what works.