For most of my career, the cost of building software made a lot of decisions for us. When a feature took weeks of engineering effort, it had to earn its place on the roadmap. AI is changing that equation.

Over the past several months, I've used Claude, Claude Code, and ChatGPT to build two applications of my own and to change how an engineering team I led delivered software in a regulated healthcare environment. The speed is real. But the more I work this way, the clearer it becomes: when building gets easier, deciding what to build, and what not to build, matters more. That decision depends on understanding the problem, the users, and the tradeoffs. AI doesn't make it for you.

I've seen plenty of shifts in more than 30 years of building software and leading engineering organizations, from BASIC to C++, Java, .NET, and modern cloud platforms. Most were incremental. This one feels different.

Leading a Team Through the Shift

At Mira Precision Health, I led technology through the company's transition from COVID and flu testing to pharmacogenomics with a small, distributed engineering team. In clinical healthcare, we couldn't trade quality, reliability, or security for speed, so how we adopted AI mattered as much as whether we did.

One project made the change obvious. A hospital integration came with hundreds of pages of custom HL7 interface specifications. Turning that into actionable engineering requirements would traditionally have taken me weeks, potentially a month or more. Working with Claude, I worked through the specifications, generated example messages, and produced the engineering requirements in about a day or less.

From there, the engineering team used Claude Code to help implement, review, and test the integration. My reviews focused on design and the quality of the deliverable: catching design or implementation that didn't match the direction, the requirements, or my expectations, and ensuring appropriate testing before deployment. Patient data accuracy and security were always the top priority. I wasn't reviewing every line of generated code, but I remained accountable for the technical direction and quality of what we delivered.

The lesson is that adopting AI is a change in how a team works, not a tooling purchase. You have to decide where human review belongs, what engineers are responsible for validating, and how to hold standards when output increases dramatically. Expecting engineers to simply produce more code misses most of the opportunity.

How I Work with AI Now

I start where I always have: with the problem. I describe what I'm trying to solve and an initial set of requirements, then ask AI to ask clarifying questions, identify gaps, challenge my assumptions, and suggest alternatives. Sometimes it surfaces something I hadn't considered. Sometimes its suggestions add unnecessary complexity or miss the actual problem. Knowing which to pursue and which to reject is where experience earns its keep.

Once the requirements hold up, I work through architecture and design before implementation begins. Claude and Claude Code are my primary tools, and ChatGPT serves as a second perspective to challenge requirements and designs. Implementation happens in small, clearly defined phases: build a piece, test it, review it, adjust, and move on. It's the same approach I've always used to reduce risk, and it matters more with AI. When code can be generated quickly, misunderstandings and poor design decisions get embedded just as quickly.

When code can be generated quickly, misunderstandings and poor design decisions get embedded just as quickly.

Why the thinking still matters

Speed Doesn't Change the Security Standard

Working code and production ready software are very different things, and AI makes them easier to confuse. I served as Vice President of Technology and Security Officer at Mira, a CLIA, COLA, and CAP accredited laboratory. I've also prepared organizations for SOC 2 audits, supported security reviews by hospitals and clinics, and led security incident response from start to finish.

At Mira, AI generated code went through the same discipline as any other code: static code analysis, a maintained dependency inventory, vulnerability scanning and triage, automated testing, and design and quality reviews against the requirements. AI can accelerate those activities, but it doesn't remove the responsibility to perform them. Just as important is deciding what goes to an AI service in the first place. Protected health information should never end up in a prompt because it was convenient.

My personal applications follow the same rules. Health Review sends the model computed summaries only, never raw health exports, plus sensitive sections only when the user explicitly includes them. Each run records which sensitive sections were sent, by name only, and no prompt or report text is ever logged. Both applications have public demonstrations that run on fictional data, with the source code open for review.

NON-NEGOTIABLES

Faster code. The same production standard.

Quality and testingAutomated tests, reviews and verified requirements
Security and privacyDependency and vulnerability checks; minimize sensitive inputs
Technical ownershipDesign judgment and accountability stay with people

From Personal Tools to Real Applications

Job Hunt started as a way to manage a complicated job search. Health Review started as a way to bring my health and fitness information together and spot trends. Their first versions were simpler still: Job Hunt began as Node.js scripts using Google Sheets, and Health Review began with Google Apps Scripts consolidating health data. Both later used SQLite as they evolved into web applications. Today, both run as multiuser applications on AWS with PostgreSQL in production and public demonstrations. Job Hunt has completed its move to strict TypeScript; Health Review is migrating incrementally.

The most important thing I decided not to build in Health Review was AI that does the math. The first version pasted raw spreadsheet rows into the prompt and let the model do the arithmetic. When a sheet failed to load, the literal text "Error fetching data" went to the model as if it were data, and a response cut off midway was treated as complete.

The second version was rebuilt on a simple rule: code computes every number, and the model only writes about them. Because every number is computed, every number the model writes can be checked. An automated pass verifies that each figure in the weekly review appears in the computed results, and that medication names, lab values, and symptoms appear only in a "discuss with your physician" list. A failed check gets one retry with the specific problems listed. If it still fails, the report is saved with visible warnings, never silently accepted. Against 14 test weeks, the first version of this design produced a clean first draft about half the time. The current version passes all 14.

The model could produce convincing analyses even when its calculations were wrong. With personal health data, I needed results I could verify, not answers that simply sounded credible.

Both applications now use automated tests, security checks, and documented architecture decisions to support small, reversible changes. I want to use AI's speed without letting either system evolve faster than I can understand, validate, and maintain it. The same discipline shapes what comes next. One of my biggest priorities for both applications isn't adding features. It's removing complexity. For Health Review, that means eliminating manual setup, eventually through a native iPhone application that connects directly to Apple Health with the user's permission, so people spend their time understanding their health information, not moving it between systems.

What This Means for Organizations

The obvious benefit of AI is faster code. The bigger opportunity is what organizations do with the capacity: improve the user experience, validate assumptions, test ideas that previously wouldn't have justified the investment, and deliver improvements in smaller, more frequent increments aligned with business priorities.

But when building becomes easier, it's tempting to fill the roadmap with whatever is technically possible. The organizations that benefit most won't be the ones generating the most code. They'll be the ones that pair faster development with disciplined product decisions and strong engineering practices, and experienced technology leaders are central to making that happen.

Still Learning

The tools are changing quickly, and some of what I do today will look different in six months. That suits me. The fundamentals haven't changed. Understand the problem. Know your users. Build thoughtfully. Test thoroughly. And be willing to remove what isn't earning its place.

AI hasn't changed what I love about building software. It's allowing me to spend more time doing it.

Explore the applications I've been building: Job Hunt and Health Review. Both have public demonstrations using fictional data, and their source code is available through my GitHub profile.

RELATED ARTICLEWhy I Built Health Review →RELATED ARTICLEWhy I Built Job Hunt →