Turning AI prototypes into launch-ready products for real users and regulators

Three people start the beta where the plan asked for eight to twelve, and rules I wrote in advance decided what that means.

A friend audits the code next week, so I spent the weekend reading it as an outsider would and removing what I could not defend.

One personal account owned every console behind the product; the fix was a second owner, and a lesson about reasons that outlive their facts.

A reminder that landed on the wrong tab, a button a friend could not read, and the research that says a word beats an icon.

A model balance that hit zero with no warning, a browser that swapped my icon for a letter, and two fixes for things that will never tell you they broke.

A wordmark picked over a dozen rounds, a three-pixel error no strip could show, and two email bugs only a real send could find.

A reminder that vanished at night, a button that went grey without saying why, and a rule I reversed, three places my product answered with silence and was wrong.

How I rewrote a data-retention promise, re-read a security standard at its source and set a test baseline, so that each one names something a reader can verify.

How I set the line between what the research supports and what a wellness app should claim, and built the page that holds it.

Why I shipped a small encryption change as two releases, and how a mistake at the smoke test proved the reversibility I had designed for.

How I decided whether to encrypt a readable summary field before a beta, by measuring the premise I had written down a few hours earlier.

An onboarding screen and a law summary went unchecked against their sources, a temporary setting outlived its test, and none had a date to be checked again.

A design note, a vendor's documented fix and my own mock-up were each wrong in one day, and each time only a real run showed it.

Shipping a home screen redesign, and how a layout bug and my own vague feedback both pointed at the same real problem.

Replacing an AI sparkle logo, and why I picked the new mark by listing where it could fail instead of where it looked best.

Redesigning a companion app's home screen so it reports the user's state without scoring them, and what five rounds of mock-ups changed.

Shipping a statutory AI-disclosure notice into a companion app's chat thread, and how reading the code changed the design record's mechanism without changing the promise.

Reordering a build queue after realizing a metric I had waited two sessions for was never going to arrive, and what else reads as fine when nobody checks the pipe.

Picking where a chat control lives by asking which state the user is actually in, and what the smaller fix would have quietly removed.

Measuring where a chat turn's cost went before cutting, and learning that fixing Luna's repeated questions had only moved the repetition to my side of the conversation.

A wording pass on Luna's questions surfaced a hidden defect, replies cut mid-sentence by a token ceiling the test suite had no rule to catch.

Shipping a morning notification in the user's own words, built so the service that sends it never has the text, and the two failures that made it real.

Adding reminders to a private journaling app meant deciding what a notification is allowed to know, and proving the answer before anyone could opt in.

Shipping an end-of-night intention taught me where precision helps a product and where it quietly turns into a liability.

Why a journal that talks back should still open on the writer's own words, and what a one-word disclosure taught me about shipping.

Why I moved the age gate behind a public landing page, and what two wrong conclusions about a blocked review taught me about stopping too early.

How I closed the data-loss gap I had been carrying since June, which gate I skipped on evidence, and what the first post-deploy failure taught me about blame.

Why I built the test that proves a one-time, irreversible data migration correct before I built the migration itself, and what that proof had to cover.

Why the recovery cues for an unfinished journal entry show no content, and why the exit popup gives people a real way to discard and leave.

Why I kept the companion's memory field as readable text while the entry itself is encrypted, and how I filtered it to earn that choice.

Designing recovery for when a user loses their encryption key, where both resetting the key and locking them out are the wrong move.

How I sequenced verification and approval for the least reversible change in the project, an encryption rollout that reached every user at once.

Why I retired a plaintext draft-saving shortcut instead of patching it, and built a replacement that saves drafts only in encrypted form.

Three decisions in one stretch of encryption work, each forcing the same choice: design honestly for the reality you have, not the one you wanted.

Why I deferred Duskglow's privacy and terms pages until the encryption architecture is built, instead of shipping disclosure copy I would only have to rewrite.

How a non-engineer PM verifies delegated technical work, and why the cleanest 'all done' report is often the one worth checking hardest.

A runtime mismatch in production telemetry surfaced via mandatory verification, and what it reveals about the structural discipline that catches what recognition-based judgment cannot.

How a single beta tester report rejected the 'monitor and see' default and surfaced a reframe of how the product treats in-flight state.

A 30-second schema check found a column-type bug that would have silently killed telemetry on the low-memory devices it most needed to see.

An exploration session testing whether you can prompt your way out of an AI tool's house style, run on the tool itself.

A couple moments today taught me the same lesson from different angles. AI tools have defaults that compound into your product, and noticing them is becoming part of the PM job.

When a voice input bug surfaced on a phone but not on the laptop where the code lived, the question wasn't what to fix. It was how to see what was actually happening.

A regression closed without a real fix, an AI agent that surfaced tension instead of choosing silently, and a governance rule whose premise had quietly expired, all in one day.

A five-element structure for delegating technical decisions to an AI collaborator when you own product vision but cannot verify the code yourself, built live during a cryptographic ship.

Why replacing a working development tool mid-project, before finishing in-progress ship work, was the right sequencing call for my AI-assisted build loop.

A UI task turned into a pressure test of every trust assumption in the encryption posture, and why that pressure test is the real work.

An admin dashboard is a product for one user and a liability for everyone else, and that reframing changed what I built and what I turned off by default.

Twelve chats turned safety infrastructure into three case studies, and the translation process surfaced product decisions the building process missed.

An eight-session sprint to feature-completeness where the hardest PM decisions were what to revert, where to draw API boundaries, and when to override your own AI's design instincts.

How mapping real AI companion lawsuits to OWASP vulnerability categories produced four concrete Edge Function fixes deployed in a single session.

Building working memory into an AI companion, letting the model author its own UX signals, and why a 429 error in a journaling app hits harder than a loading spinner.

A stateless search architecture that eliminates the vector database entirely, compliance features designed as architectural patterns instead of checkboxes, and managing AI development context as production infrastructure.

Migrating off a no-code platform mid-build, designing a summarization feature as a side-channel architecture, and the debugging tax that comes with every AI-generated line of code.

Why crisis detection must bypass the LLM entirely, how adversarial testing exposed the cost of false positives, and building an AI personality framework where tone carries real risk weight.

Seven security layers mapped to OWASP LLM Top 10, a system prompt rewritten as a behavioral spec, and the discovery that your safety infrastructure can fight itself at the worst possible moment.