Why "just trust the AI" doesn't work

Over the past year, AI coding assistants have become a real part of my daily iOS workflow. I use Claude Code and GitHub Copilot regularly, on production code shipping to millions of users. But the honest answer to "how do you use AI in your development process" isn't just a list of tools — it's a discipline.

The biggest mistake I see engineers make with AI-assisted development is treating generated code as trusted output. It isn't. It's a first draft, written by something that's confident but has no accountability for what ships. So I've settled on a simple mental model: review every AI suggestion with the same scrutiny I'd apply to a junior engineer's pull request.

What that looks like in practice

When Claude Code or Copilot suggests an implementation, I ask the same questions I'd ask in any code review:

• Does this actually solve the problem, or just look like it does?
• Are there edge cases the suggestion missed — empty states, concurrency, error paths?
• Does it match the architecture and conventions already in the codebase, or is it quietly introducing a new pattern?
• Would I understand this code in six months without the AI's context?

This matters most in areas where correctness is subtle. Swift's concurrency model is a good example — I've seen AI-generated code that compiles cleanly and looks idiomatic, but resumes an async continuation more than once under specific timing, or silently swallows a cancellation. Nothing about the code looks wrong. It only fails under conditions a quick glance won't catch, which is exactly why it needs a real review pass, not a rubber stamp.

Where AI genuinely helps

None of this means I'm skeptical of the tools — quite the opposite. Used well, they meaningfully speed up the parts of development that are mechanical: scaffolding boilerplate, writing test cases for a spec I've already thought through, exploring an unfamiliar API, or getting a first pass at a UI layout. Recently I built a feature on Apple's FoundationModels framework, and AI tooling was genuinely useful for exploring the API surface quickly — while the architectural decisions (how the feature fit into the existing module structure, what the public interface should look like) stayed firmly in my hands.

The speed gain is real. But it's a speed gain on execution, not on judgment.

The takeaway

AI-assisted development isn't about writing less code yourself — it's about redirecting your attention. Less time on typing, more time on review. If you're integrating these tools into an iOS workflow, the question worth asking isn't "how much can I offload to AI," it's "am I still reviewing this as carefully as I would my own code, or my teammate's?" That discipline is what makes the speed worth it.