How I Use AI to Generate 100% of My Code in 2025

Over the past six months, I’ve evolved my development workflow to the point where AI generates 100% of my production code. Not snippets or boilerplate, basically everything. I’m 10x faster than I was writing code manually.

This isn’t theoretical. I’m shipping real products using this workflow. Here’s how I do it and what I’ve learned.

The Core Stack

Model: Claude Sonnet 4.5 - the best model I’ve found for complex architectural decisions and multi-step reasoning.

Development Environment:

  • Cursor for visual navigation - I prefer to see my entire codebase at once
  • Claude Code for my coding agent
  • Type-based languages - TypeScript for web apps, typed Python for backend APIs. AI does better when types are defined.
  • Monorepos - After going the microservice path for years, I’m moving back to monorepos. AI performs better when it has all the context of the application. I’ve been using Epic Stack as a decent starting point for new projects - Remix.js with TypeScript, less magic than Next.js, closer to web fundamentals. I swap out hosting (AWS) and database (Postgres) as needed, but it’s a decent foundation.

Speech Recognition: Voice Type - a Mac app I found via Reddit. Changed my workflow completely. I can move at the speed of thought - talking is way faster than typing. Control+V starts listening, injects text wherever my cursor is. Handles technical terms well and, crucially, handles long pauses. I can stop mid-thought for 30+ seconds and pick up where I left off. Basically, I can stream of consciousness talk through complex features, capturing everything I’d normally lose trying to type it out.

My Step-by-Step Workflow

You basically need to emulate the same process that an expert software engineer would use when coding.

  1. Learn - Build up context
  2. Make a plan - Talk through it with voice
  3. Review the plan - Iterate until zero ambiguities
  4. Execute - Commit current work, start fresh thread, build it
  5. Code review and refactor - Small issues? Fix in place. Fundamental problems? Wipe and restart fresh
  6. Write tests - Write comprehensive tests
  7. Run tests, lint, type check - All automated

The Details

Learn (Step 1)

When starting with a new codebase or major feature, have the AI review everything and document it. Think of this as onboarding a senior engineer. Comprehensive documentation, clear architectural decisions, good test coverage.

Make a plan (Step 2)

Speech recognition changes everything here. Of course, it depends on the complexity of the feature, but I can talk through a complicated new feature for 10-20 minutes, moving at the speed of thought. Business context, system architecture, user experience, technical approach. Stream of consciousness. Pause, backtrack, refine. Voice Type handles all of it.

I save the plan to a local file.

Review the plan (Step 3)

I start a new Claude thread and have it review the plan. I ask explicitly: “What’s unclear? What questions do you have? What edge cases am I missing?”

We iterate until there are zero ambiguities. This prevents wasted implementation work.

Execute (Step 4)

Once the plan is solid: commit current work to git, start a fresh Claude thread with the plan, have Claude review it one more time, then execute.

During execution, I’m reviewing at a high level. Catching architectural issues, thinking about broader system implications.

Code review and refactor (Step 5)

Critical decision point: small issues? Fix them in place. Fundamental problems? Wipe everything and start fresh.

With AI, regeneration cost is basically zero. Here’s what I’ve learned - if Claude gets stuck on something and I try fixing it in place over and over and it keeps getting it wrong, I just wipe everything. Start fresh, give it all the context again, maybe add anything it was missing or confused about, and it’ll often get it right in one shot. Way faster than iterating on broken code.

Write tests (Step 6)

AI writes comprehensive tests.

Run tests, lint, type check (Step 7)

Run the test suite, type check everything, lint and format. All automated.

Parallel Execution: Multiple Agents

For large features, run multiple Claude instances simultaneously.

Same codebase, different areas:

  • Agent 1: Frontend components
  • Agent 2: Backend API
  • Agent 3: Infrastructure

Same codebase, same files:

  • Create multiple local copies of the repo
  • Each agent works on its own branch
  • Integrate their work manually after review

You can make progress on frontend, backend, and infrastructure at the same time. Massive productivity multiplier.

What Makes This Work

  • Voice-driven planning - Move at the speed of thought, capture architectural thinking before implementation
  • Clear documentation - Treat your codebase like you’re onboarding a senior engineer
  • Unified context - Monorepos or consolidated codebases let the AI see the full picture
  • Disciplined review - You’re the architect and tech lead, even if you’re not writing code
  • Willingness to restart - Don’t salvage bad implementations, regenerate from scratch

The Results

Shipping production code 10x faster than when I wrote everything manually.

My role shifted from writing code to:

  • Architectural planning and requirements thinking
  • Code review and quality assurance
  • Context management across multiple agents
  • Integration and coordination

I spend more time thinking about what to build and why than how to implement it.

I’m now shipping features in a day or two that would have taken a week a year or two ago. Cranking through frontend, backend, dev ops, data pipelines, all of it.

But here’s the thing - this only works if you’re actually an experienced engineer. AI will miss security issues, infrastructure optimizations, poor database schemas. You need to catch these things. The difference between this and vibe coding is you’re still the expert driving decisions. You can ship fast either way, but only one approach builds something you can scale long-term.

If you’re building with AI and want to compare notes, reach out at hello@michaelfrye.me.