Shipping More Code Than Ever With AI-Assisted Development

I built two applications over the Christmas break without writing a single line of code with Claude Opus 4.5 in VS Code.

Prior to this “Christmas break”, for the entire month of December, I’ve been using Opus 4.5 as my coding partner in VS Code. I shipped more real world working code than any other month in my career of ~20 years (yes I’m old).

The two apps I built over the break are DNS Lens and User Secrets Manager, and I’m pretty happy with how they turned out.

DNS Lens is a combination of a lot of the tools I use day to day for the hosting side of my business from various spaces around the internet.

User Secrets Manager is again a “scratch my own itch” kind of tool that let’s me view, edit and copy settings from various .NET User Secrets files across multiple projects. Things like SendGrid keys that are used for multiple projects within a larger system.

From Writing Code to Directing Code

The shift has been quite a mindset change for me. Instead of typing out code manually, with the help of the older intellisense or as Scott Hanselman put’s it, the newer Copilot “Spicy Autocomplete”, I’m describing what I want to achieve and iterating on the results with the AI.

There’s a lot of people calling AI code “slop” but I’ve found quite the opposite experience. Maybe back in the early days (9-12) months ago, but now, with Opus 4.5, the code is almost always as good or better than I would write it.

It’s actually probably better because I’m lazy and often don’t code defensively enough (in personal projects anyway). I also often take the easy, not the complete way. Given that the AI can write boilerplate code near instantly, there’s no reason to have it write it as it should be.

I still read every line of code and will often get it to rewrite parts that it either got wrong due to missing context, or just a plain mistake, but that’s happening less and less as I learn to prompt better and give additional context where I should.

VS Code Workspaces for Legacy Migrations

One of the most powerful things I’ve found is using VS Code’s Workspaces functionality for large migration projects.

I’m currently working on migrating a legacy system that has:

An older Windows Forms desktop application
A WCF-based API service
A new Blazor Server application that will replace both

By adding all three projects to a single workspace, I can give the AI complete context about both the source and target systems. This has made migrating complex functionality surprisingly easy.

The PRD-First Approach

Before diving into code, I have the AI create a detailed Product Requirements Document (PRD) for each piece of functionality I want to migrate. This has worked really well because:

Writing out requirements exposes gaps in my own understanding
The PRD becomes a checklist for implementation
The AI can reference back to it during implementation

An Example Migration Workflow

Here’s an example of how I approached migrating a complex feature. I gave the AI a prompt something like this:

This workspace contains three projects: the new ASP.NET-based Blazor app that will eventually replace the older Windows Forms desktop application and the legacy WCF API. The user control in the desktop app manages a category system. The current implementation has a cluttered UI and confusing workflow. Please do a detailed analysis of this functionality including the API calls used to retrieve and save data, and prepare a plan to rebuild this in the new Blazor app. The implementation should follow the existing CQRS pattern using MediatR in the Application Core. Please save the plan in the Documentation folder.

The AI then goes off and analyses the existing Windows Forms user control, traces through the WCF API calls, understands the data model and business logic, and creates a detailed migration plan following my architectural patterns. It saves the documentation, and from there, I can review the plan, provide feedback, and have the AI implement each component step by step.

What Made This Work

A few things came together to make this month exceptionally productive.

Clear Communication

The better I described what I wanted, the better the results. I learned to be specific about the architectural patterns I wanted followed, the existing code conventions in the project, and what I wanted the user experience to be.

I rarely accepted the first output. The workflow became: describe the requirement, review the implementation, provide specific feedback on what to adjust, and repeat until I was happy.

This iterative process often led to better solutions than I would have written myself. The AI would sometimes suggest improvements I hadn’t considered.

Trust but Verify

While I wasn’t writing code, I was still reading every line. Understanding what the AI produced was essential for catching subtle bugs, ensuring security best practices, and maintaining consistency across the codebase.

I also learned a few new techniques along the way - the AI often showed me better ways to do things than I would have done myself.

Breaking Down Complex Tasks

Large features got broken into smaller chunks. Instead of asking for an entire feature at once, I’d request the data model first, then the business logic, then the UI components, and finally the integration. This gave me checkpoints to review and course-correct.

The Results

By the end of December, I had a significant portion of a legacy system migrated to modern architecture, and comprehensive documentation for all new functionality.

What This Means Going Forward

The role od me as a developer (and manager of developers) is shifting from “person who writes code” to “person who understands problems and directs solutions.”

The skills that matter most now are domain knowledge, architecture decisions, code review, and clear communication. If you haven’t tried AI-assisted development seriously, I’d encourage you to give it a real go. Not just for generating a function here or there, but as a full partnership throughout your development workflow.

This past 6 weeks has shown that this is the future of software development. If you’re not learning to utilise these tools, then you’ll be left behind quickly. And by quickly I mean in a matter of months, not years.