Pair Programming with Claude Code: Brilliant in Parts, Unreliable in Others

This week I experimented with vibe coding using Claude Code, an AI assistant designed to work directly with your entire project codebase. My initial impression was overwhelmingly positive. It felt like the best pair-programming experience I’ve ever had. You simply describe what you want, and Claude Code inspects your repository, proposes a solution, makes the necessary edits, watches build warnings, and iterates until it works. When I point Claude Code to specific files that need refactoring or optimization, it readily agrees and gets to work—always polite, always accommodating, and unfailingly patient in a way you can’t always expect from a human collaborator.

But while the experience was smooth in some situations, it was inconsistent in others.

Migration from Next.js 15 → Next.js 16

I asked Claude Code to upgrade a project from Next.js 15 to 16. It researched the migration steps, followed Vercel’s guide, and began updating the codebase. After inspecting the number of files, it decided to use a codemod and executed:

npx @next/codemod upgrade 16

Then it checked for async APIs, added missing awaits, fixed the Next.js config, and updated my next dev/build commands to include –webpack because I’m using a custom Webpack plugin.

When I ran the app and followed the warnings, Claude Code and I resolved the remaining issues together—and overall, this part of the process was surprisingly smooth. It genuinely felt like collaborative development.

Migration from Ant Design v5 → v6

The second challenge, however, was a different story.

I asked Claude Code to migrate the UI library from Ant Design v5 to v6. After the upgrade, I immediately noticed FOUC (flash of unstyled content). This is where the experience deteriorated. Claude Code began modifying configs, wrapping layouts, tweaking the custom registry, and experimenting with different integration patterns. Each iteration introduced batches of file changes—additions, removals, rewrites. After hours of back-and-forth, it became unclear what the current state of the project even was.

For this task, I found that doing the migration manually would probably have been faster and less chaotic.

Detecting Missing use client Directives

To test a simpler, more targeted request, I asked:

“Find all Next.js components that use client-side features (e.g., React hooks) but are missing the use client directive, and add it."

Claude Code searched the codebase, ran greps, and reported results—but still missed some components that clearly needed use client. This reinforced an important point: while Claude Code is extremely helpful, you cannot rely on it to be exhaustive or perfectly accurate.

Claude Code as a QA Partner: Surprisingly Excellent at Test Planning

I also asked Claude Code to generate test cases for QA based on the project’s Next.js app structure and components. Here it genuinely impressed me.

Claude demonstrated a solid understanding of the architecture and functionality of the application. It produced a neatly organized and highly detailed list of test cases that one should consider when performing regression testing. The accuracy was so high that I barely had to revise anything.

Even more surprising, it included areas I hadn’t explicitly requested:

• API testing cases
• Integration tests
• Performance and SEO tests
• Security tests
• Cross-browser and responsive testing
• Recommendations for automated testing strategies

For this purpose, I believe Claude Code is an excellent choice. It can generate a comprehensive test plan effortlessly—and, even more impressively, it can help keep that plan up to date as the application evolves. This makes it a genuinely valuable tool for maintaining test coverage and consistency throughout ongoing project updates.

Conclusion

Claude Code delivers an impressive—and at times genuinely delightful—developer experience, especially when the task aligns with its strengths. For structured work like a Next.js migration or generating comprehensive QA test plans, it can save hours of effort and feel like a highly capable teammate. Its ability to understand project architecture, propose thoughtful test coverage, and keep documentation or test plans up to date is particularly noteworthy.

However, when it comes to complex transformations with many interdependencies—such as UI framework migrations or project-wide architectural shifts—Claude Code can drift, produce inconsistent changes, or leave the codebase in an uncertain state. These types of tasks still require careful human oversight.

In short: Claude Code is powerful, but not infallible. It excels at guided refactoring, structured transformations, iterative debugging, and surprisingly robust test-plan generation. But for large, intricate, or ambiguous changes, human judgment remains essential.