I Built Four AI-Assisted Apps. Here's What Changed.

Across about a month — mostly on weekends after full-time work — I built and shipped four production AI-assisted applications, each live, open, and inspectable, each with a case study and a public repo. They look like four unrelated products. They were really one experiment: what actually changes in how a senior engineer works when AI can write most of the code?

The short answer: the typing got faster and the thinking got more important. Here's the longer answer, one app at a time, then what connects them.

1. RetireCheck — domain logic and deterministic decision support

A calculator that answers a genuinely hard question: will my retirement savings last? The temptation with any calculator is to return one confident number. That's the wrong architecture for a question full of uncertainty.

So RetireCheck runs Monte Carlo projections and presents a distribution of outcomes with plain-language disclaimers — a range, not a prophecy. The domain logic is deterministic and testable; the UI is a guided wizard so a non-expert can get a credible answer without advisor-grade onboarding. No LLM on the calculation path — AI helped me ship it, not run it.

2. SleepCheck — privacy-first, local-first product design

A wind-down companion: soundscapes, bedtime stories, guided breathing, a sleep timer. A wellness app like this is a trustproduct before it's a feature product, and trust is an architecture decision, not a privacy-policy paragraph.

SleepCheck is local-first: preferences live on the device, there is no account, and nothing is sent to a server to be tracked. Optional AI can generate bedtime story text, but the player works without it — capability is optional, calm is not. The hardest decisions were subtractive: everything I chose not to build or collect.

3. AI Production Readiness Advisor — production AI architecture and guardrails

This one assesses whether an AI system is ready for production, across eight dimensions, and returns a readiness band. The obvious failure mode: let a language model score itself. Then the tool is theater.

So the Readiness Advisor scoring engine is deterministic and runs server-side; hard gates (HG-01 through HG-10) can cap the result; and the OpenAI layer only narrates. The model can explain risk; it can never widen the band. Around that sit schema-validated output, input redaction, rate limits, cost caps, and a scores-only fallback when the model is unavailable.

4. HabitCheck — behavior design, recovery, and responsible AI coaching

Most habit apps punish a missed day with a broken streak — which quietly trains people to lie, tapping “done” to protect the run. That's a behavior-design bug disguised as motivation.

HabitCheck separates two things the UI keeps visibly distinct: Facts(the week's truth, computed in code) and Coach (optional AI behind per-action consent). Recovery is a real path, not a rewrite of history; a smaller version counts as recovery, not full completion. The model never invents a checkmark. Wellness support, not medical advice.

What AI accelerated

Genuinely a lot. AI assistants collapsed the distance from idea to a running app: scaffolding, boilerplate, UI exploration, wiring, refactors, first-draft tests, and documentation. Work that used to take a weekend of setup happened in an afternoon. Four apps in a month is only possible because the assistant absorbed the mechanical majority of the work.

What still required human judgment

Everything that decides whether the app deserves to exist. Framing the actual problem. Choosing the boundaries — what the system will and won't do. Deciding what never to collect (SleepCheck), what never to fake (HabitCheck), what the model is never allowed to overrule (Readiness), and when a number must be a range, not a promise (RetireCheck). Owning the risk when it's wrong. The assistant proposed constantly; it never once decided.

The architecture principles connecting all four

Four different products — and four different runtime AI postures: none on the critical path (RetireCheck), optional wellness capability (SleepCheck), enterprise gates with narrated-only bands (Readiness), and a consumer coach OS with Facts in code (HabitCheck). The same handful of principles underneath:

• Deterministic core, AI at the edge. Scores, week totals, and financial math live in testable code. AI narrates and suggests around them — never the system of record.
• The model never owns the verdict. Bands, completion, and projections: the model can describe them, never set them.
• Local-first and data-minimized by default. Collect the least; keep it on-device when trust is the product promise.
• Advisory, not authoritative. Disclaimers, ranges, and honest limits everywhere.
• Consent gates any model call that touches personal data.
• Build → Validate → Improve → Document → Share — the same loop, every time.

The model creates capability. Architecture creates trust.

What comes next

The series continues the same way it started — ship something real, prove it in production conditions, and write down the decisions so the reasoning outlives the launch. Next: deeper evaluation and observability for AI features, reusable design and architecture patterns across the family, and likely a fifth app — chosen by the question it lets me answer honestly.

If you're building with AI, the question worth asking out loud is: what's the one decision you refuse to hand to the model?

Disclaimers: SleepCheck and HabitCheck are wellness companions — not medical advice. Readiness Advisor is advisory only — not a certification. RetireCheck provides estimates only — not financial advice.