A grounded, no-hype look at how AI actually changes software delivery — the real speed gains, the remaining bottlenecks, and the human-in-the-loop pattern that ships working code.

The Problem

Every developer has seen the demos. A prompt produces a full-stack app in 30 seconds. The CTO forwards you the tweet. “Can we do this?”

The gap between the demo and production is still enormous. AI can generate code faster than any human. It cannot — yet — guarantee correctness, design for maintainability, or understand your specific business constraints. The art of AI-assisted development in 2026 is knowing exactly where to insert the human.

This is the same discipline behind the three AI agents I run in production — the engineering pattern that makes a model dependable, not the demo.

---

What AI Actually Accelerates

1. Boilerplate and scaffolding (real, provable)

Generating an Express route with validation, error handling, and tests from a schema definition. Writing a web form with 15 fields, each with its own validation rule. Setting up a database schema from a diagram.

These tasks have clear patterns. AI produces them in seconds. The human reviews the output — not writes it from scratch.

Realistic gain from my own project work: several times faster on greenfield CRUD endpoints — roughly 4× in my experience.

2. Test generation (real, but needs review)

“Here’s the function. Write tests for happy path, edge cases, and error states.”

In my experience most generated tests are usable as-is; a meaningful fraction test the wrong thing, mock too aggressively, or miss a critical edge case. The human’s job is to spot those — which is still faster than writing all of them.

3. Code review prep (real, underused)

AI can summarize a pull request: what changed, which files are high-risk, whether the tests cover the changed paths. It can flag missing error handling, unchecked nulls, and SQL queries without indexes. This doesn’t replace human review — it pre-digests the PR so the human reviewer can focus on architecture and intent, not syntax.

---

What AI Still Can’t Do (and why it matters)

1. Design for the business, not the schema

AI can generate a normalized database schema from a description. It cannot know that your client’s “customer” entity actually represents three different legal entities depending on the country — a constraint that emerged from a conversation with the CFO, not the data model.

2. Make architectural trade-offs

“Should this be a separate microservice or a module in the monolith?” AI can list pros and cons. It cannot weigh your team’s operational capacity, your deployment pipeline, or the political reality of your organization.

3. Guarantee correctness

AI-generated code passes the tests you wrote. It may still have a race condition under concurrent load, a memory leak in the error path, or a security vulnerability in the auth middleware. These are precisely the bugs that static analysis and tests often miss — and they’re the ones that cost the most in production.

---

The Pattern That Ships: Human-in-the-Loop

Here’s the workflow I use on every project (detailed on the How I Work page):

Discovery (human) → Architecture (human)
                        ↓
              AI drafts the implementation
                        ↓
              Human reviews architecture & code
                        ↓
              AI generates tests
                        ↓
              Human verifies coverage & intent
                        ↓
              CI/CD deploys

The AI accelerates the typing — the translation from a clear design to working code. It does not replace the thinking — the design itself, the trade-off analysis, the business context.

This is why I describe what I do as “AI-assisted,” not “AI-powered.” The distinction matters: the human is the pilot; the AI is the autopilot on a straight road.

---

Tools That Actually Help

I use a small, curated stack — not 30 plugins:

Tool	What it does	When I use it
Claude Code / OpenCode	Full-file generation from specs	Greenfield features, refactors
GitHub Copilot	Inline completion	Routine code, type definitions
Windsurf	IDE-embedded agent	Quick edits, file navigation
Context7	Live library docs	When an API changed since training data
Serena	Symbol-level code navigation	Understanding unfamiliar codebases

None of them replace judgment. Together, they cut the boring parts by roughly half.

---

TL;DR

What’s real	Large speedups on boilerplate, test generation (majority auto, rest reviewed), PR pre-digestion
What’s still hype	Autonomous architecture, business-context understanding, guaranteed correctness
The pattern	Human designs → AI drafts → Human reviews → AI tests → Human verifies → CI/CD
Tool philosophy	Small curated stack, not 30 plugins. AI is the autopilot; human is the pilot.
See also	Three AI Agents I Run in Production · How I Work

---

Want AI in the loop without losing the senior judgment that keeps code maintainable? I design the architecture, draft with AI, and review every line by hand — book a free 20-minute fit call.