3/22/2026

The Project Was Stalling. Then I Brought In AI.

An honest account of adopting AI tools mid-project on a production full-stack LMS — what changed, what didn't, and what I'd do differently.

I asked an AI to help me finish my project. It did not ask why it was only half done. I respect that.

- Me, apparently

About halfway through building a Learning Management System for a client, I had to make a decision.

The foundation was solid. The architecture was right. But the project had slowed — not because of bad planning, but because side projects don't pause when life doesn't. I had complex features still on the roadmap, security debt piling up, and testing ahead. I was moving, but not fast enough. And the client noticed.

That's when I started integrating AI tools seriously into my workflow. Not from day one — as a deliberate decision to change how I was working midstream.

This is what happened.

The Project: What I'd Already Built

LMS Academy is a full Learning Management System — content management, user assignments, credentials, awards, learning tracks, and event registration. Production software for a real organization.

The stack I'd established before AI entered the picture:

• .NET 8 minimal API backend — clean architecture with Web.API, Application, and Persistence layers, Entity Framework Core on SQL Server
• Next.js 14 frontend — App Router, Redux Toolkit with RTK Query and Material-UI
• Azure infrastructure — Blob Storage for SCORM content, Azure SQL Database, containerized deployment
• Established patterns — endpoint registration via IEndpointRegistration, Redux slice structure, service layer boundaries

The architecture decisions were made. The patterns were set. What remained was executing the back half — and executing it well.

Where the Project Had Stalled

Not enough hours in the day. The trouble with all side projects. Other commitments were draining my time and mental energy, leaving little of either for work that demanded both.

Security and technical debt. The first half of a project accumulates decisions made under speed pressure — things that work but aren't clean. Auth patterns that need tightening. Inputs that need validation. I knew the surface area was there. I just couldn't sustain the focused attention it required.

The hardest features. Server-side paging and search across multiple endpoints. Complex assignment and credential logic. Requirements were clear; the implementation just took real effort.

Testing. Unit tests, UAT coordination, debugging. Testing is where solo projects quietly cut corners — especially when you're already running low.

What Changed When I Brought AI In

The biggest shift wasn't technical — it was capacity.

The problem wasn't skill or complexity. It was bandwidth. Other commitments don't pause because a side project needs attention, and what was left over wasn't enough to sustain the deep, focused work the back half demanded.

What AI changed wasn't the quality of my thinking — it was the cost of getting started. When you have 45 minutes and a tired brain, the barrier to sitting down with a hard problem feels enormous. Having an AI to think alongside — to frame the problem, draft the first pass, work through a checklist — lowered that barrier enough that those 45 minutes actually produced something.

It didn't give me more hours. It made the hours I had count for more.

Security review became systematic. Running endpoints and data flows past an AI reviewer — specifically asking for authentication gaps, unvalidated inputs, and missing authorization checks — surfaced issues I knew existed but hadn't prioritized. It wasn't a professional audit. But it gave me a structured pass I wouldn't have done as thoroughly alone, and it did it fast.

Technical debt got addressed rather than deferred. Refactoring sessions that felt expensive became approachable. Describe the pattern I wanted, share the existing code, work through the migration collaboratively. The debt I'd been stepping around got cleared.

Complex features accelerated. The server-side paging implementation — filtering, sorting, and paging at the database level across multiple endpoints — is a good example. AI helped me think through edge cases, draft implementations, and iterate faster than I would have alone.

Testing went from corner-cutting to thorough. AI assistance on test scaffolding — arrange/act/assert structure, mock setup with NSubstitute, Shouldly assertions — removed the friction that makes developers skip tests. The meaningful logic was still mine. But the cost of writing tests dropped enough that I actually wrote them.

Debugging compressed. In UAT, when bugs surfaced between the Next.js frontend and .NET backend, having an AI to trace the data flow and identify where the contract broke down turned multi-hour sessions into focused ones.

What Didn't Change

The architecture was already set, and AI worked within it. The endpoint registration pattern, Redux slice design, service layer boundaries — none of that was up for reconsideration. AI was useful precisely because I could hand it that context and it worked with the existing structure rather than against it.

The judgment calls were still mine. When a suggestion conflicted with an established pattern, or when output about Azure configuration needed verification, experience was what caught it. The tool is only as good as the person directing it.

The client relationship, requirements clarity, delivery accountability — none of that changed. AI accelerated the engineering work. Everything else was still on me.

The Honest Takeaway

Bringing AI into a stalled project mid-stream worked. Not magically — deliberately. Security review, debt reduction, complex feature completion, testing, debugging — those are exactly the phases where solo developers slow down or cut corners. AI provided consistent forward pressure when I needed it most.

If I were advising another independent developer: AI tools aren't most valuable when you're in flow on work you know how to do. They're most valuable when the work is hard, the surface area is wide, and you need something to help you stay systematic and keep moving.

That's exactly where I was. And it's exactly where they helped.