Blog #6: Vibe Coding Outside Your Stack
Introduction
I wanted a dictation app for personal notes that never sends my voice anywhere. The options were either cloud-based or subscription-based. So I built my own one last weekend.
The thing is, my last Android app came from following a tutorial years ago. At this point I have seven years as a developer and tech lead, but none of them in Kotlin, Jetpack Compose, or native C++ through the NDK. This is not intended as a tutorial but a brief on what I believe carried over and what did not based on my experience.
The source code can be found here
Requirements are still the job
The most useful hour went into the spec, not the code. Before the AI wrote a line, I had a short list: an on-device Whisper model, fully offline, download a model or import my own, no recording time limit, and a way to get the text to my PC. I also wrote down what I did not want: no analytics, no accounts, nothing extra.
That is a refinement session, not prompting. Define done, name the constraints, write down the non-goals. An AI is a very fast engineer who will build anything ambiguous in the most elaborate way possible.
I also gave it a build order: native layer first, then models, recording, transcription, UI, and CI last. This is the same way I would sequence a team, with the riskiest integration first.
What transferred, and what did not
What transferred:
- Knowing which questions to ask. I did not know Android's foreground service types. I did know that a two-hour recording can't live in memory and that a long job has to survive the screen turning off. Asking the right question got me the right API.
- Reading code I did not write. Years of PR review turned out to be the core skill.
- Smelling scope creep, mine included.
What did not:
- Platform gotchas. Permissions, battery optimisers, and file names with colons that Windows refuses to accept. I only knew about these because I asked.
- Judging what's idiomatic. I can tell when code is clear. I can't tell whether a Kotlin developer would write it that way. For software with one user, I have decided this is fine.
Testing it like a user
Meeting the requirements and compiling cleanly was the easy half. A week of actually using it found:
- A silent failure. Speaking more than one language into the English-only model produced no error, only bad or empty output.
- A stuck progress bar. The progress bar sat still while transcription was still running in the background, so I force-closed the app and killed the job. The model only reports success or failure at the end, so I replaced the bar with a rough estimate based on timings from test runs. It isn't precise, but it tells you the app is still working.
- A missing feature. Once I used it for a while, I wanted playback, so I could listen when a transcript looked wrong.
No unit test would have caught any of these. The progress bar addition is my favourite: the code was correct, and the user (me) did the wrong thing because the screen told him to.
Then I had an agent audit it
I started a fresh agent session with no context from the build and asked for a bug and security audit. Each finding needed a severity, a confidence level, and the code it pointed to. Some highlights:
| ID | Severity | Confidence | Finding |
|---|---|---|---|
| BUG-001 | High | Medium | Unsaved edits can overwrite a freshly finished transcript |
| BUG-002 | Medium | High | A full disk while recording crashes the app, then crashes it on every launch |
| BUG-003 | Medium | High | A full disk during transcription makes the service retry forever; Cancel doesn't stop it |
| SEC-001 | Low | High | A crafted model file kills the app during import (native abort) |
| SEC-002 | Low | Medium | Default task affinity allows task hijacking on Android 8–10 |
| SEC-003 | Low | High | A deleted transcript lingers in the share cache |
| BUG-008 | Low | Medium | The wake lock expires after 4 h on a single note |
In total there were 8 bugs, 5 security notes, and a handful of lint and accessibility items. I did not know task hijacking was a thing until this report.
But... but asking AI to review AI code a bad idea right?
I asked myself the same thing. It's the same kind of model, so it has the same kind of blind spots. Partly true. What I think made this useful:
- A separate session. The reviewer did not know what the builder intended, so it judged the code, not the intentions.
- Confidence levels and code references, not vibes. A low-confidence finding is a lead, not a fact.
- I checked findings against the code before accepting a fix.
Then compare the two lists. There's no overlap. The agent found edge cases: full disks, malformed input, OS quirks. I found experience problems. Neither replaces the other. I treated the audit like a second reviewer, not a sign-off, the same way nobody treats an approved PR as proof there are no bugs.
Throwaway personal software
Building a tool for one user used to take multiple weekends (that too only if you really really wanted it!). Now it takes evenings. That changes the math. My app doesn't need to be general, maintainable for years, or published. It needs to do my five things and not lose my notes. If it rots in two years, I will rebuild it, probably faster.
What is not throwaway is the habits: spec it, sequence it, use it like a user, and get a second pair of eyes. Seven years bought me those, not the stack.