Preface

I've been pushing the limits of vibe coding lately, mainly with Claude Opus 4.5 paired with GitHub Copilot Pro — burned through nearly 16 units of usage and shipped four real projects. After getting hands-on, here's how I feel about it: AI is fantastic for prototypes, small projects, or PoCs. But once a project gets bigger and the logic gets denser, all sorts of limits and gotchas surface one after another.

This article is the most honest, real-world take from that period — and how to actually work with AI day-to-day.

1. AI gets stuck on complex or ambiguous requirements

This is one of the most obvious limits of AI-assisted development right now. When the feature spec is too complex or not specific enough, the AI tends to:

• Halt halfway and need a human to hit "continue"
• Output incomplete code on large or complex features
• Iterate endlessly without ever hitting the target

One thing to add: even if the spec is detailed, AI doesn't necessarily nail it in one shot. It often lacks project context (existing flow, untouchable boundaries, implicit rules) and starts drifting at some step.

Common reasons:

• Didn't make clear what can't be changed and what must be reused
• Missed non-functional requirements like error scenarios, permissions, performance
• Cross-module coupling — AI fills in the blanks unilaterally and ends up inconsistent

Real example: When I asked the AI to refactor a feature spanning multiple modules with complex business logic, it kept "getting lost" mid-execution — forgetting parts it had already finished, or misreading the requirements.

Recommended approach:

1. Decompose the task: break a large feature into small steps and have AI complete them one by one
2. Be explicit: give concrete input/output examples to reduce ambiguity
3. Set boundaries: clearly tell AI what to leave alone and what's the focus

2. Rewriting systems leads to hallucinations or scope creep

This left a strong impression. Even when I provided the old code as reference, without watching the AI's output it would still:

• Hallucinate: invent APIs or methods that don't exist
• Over-extend: add features or design patterns nobody asked for
• Forget context: produce code with inconsistent style across sections

Real example: When porting a module from a legacy system, I provided the complete old code, but the AI still "freestyled" in places, using library methods that simply didn't exist. If you don't read carefully and just ship it, things will explode in production.

Recommended approach:

1. Review in chunks: don't let AI produce huge blocks at once — check section by section
2. Constrain explicitly: in the prompt, emphasize "use only existing APIs" and "don't add extra features"
3. Manual review: code AI produces must be eyeballed personally — especially the critical logic

3. Agent Skill: AI that does more than write code

The most interesting discovery this round was the Agent Skill concept. Through MCP (Model Context Protocol), AI can have "execution capabilities," not just produce text or code.

What is Agent Skill? In simple terms, it's a set of pre-defined "skills" that let AI:

• Run terminal commands
• Manipulate the file system
• Call APIs
• Query databases
• Manage Git operations

Real applications:

• Ask AI to check Git status and create commits
• Have AI run tests automatically and report results
• Integrate deploy flow — AI can run it with one command

This turns AI from "consultant" into "assistant" — actually able to do things, not just give advice.

4. Frontend dev pairs really well with templates

This is one of the best-fit scenarios for AI-assisted development right now. As long as:

• The requirement isn't too complex
• You have an existing template or UI framework
• You have a clear design or reference

You can confidently hand it off to AI, and it'll quickly produce frontend code that meets expectations.

Frontend tasks well-suited for AI:

• Layout (HTML/CSS)
• Component encapsulation (React/Vue Component)
• Form handling
• API integration
• Simple interactive effects

Cases where it's less suitable:

• Complex state management logic
• Deep custom animation effects
• Performance-tuning adjustments

5. C# and Java burn Tokens faster than scripting languages

This is an easily overlooked cost issue. Because of how C# and Java work:

• Verbose syntax: same logic takes more lines
• Strong type system: requires defining more types and interfaces
• More OOP and abstraction layers: large projects often have many layers and interfaces (DTO / Service / Repository / Interface) or Abstract classes — once context grows, it eats more Tokens
• Namespaces and imports: every file has a pile of references

This means AI burns through Tokens noticeably faster on these languages than on scripting languages.

To avoid heavy Token consumption, I'll ask AI to first write a Skill.md or Instruction.md based on the existing code structure.

For smaller projects I tend to use Next.js for full-stack development — it's more Token-efficient.

I later chose to develop with Next.js, mainly because:

• Same language across frontend and backend: TypeScript/JavaScript everywhere, no context switching between C# and frontend
• Smaller context scope: within one project, AI grasps the overall architecture more easily
• Lower Token consumption: same feature uses fewer Tokens than a C#/.NET project
• Strong support for popular frameworks: AI's understanding of Next.js is high, and the code quality it produces is more consistent

A bonus: when I ask AI to handle a feature, it can see both the frontend component and the backend API Route at the same time, making it easier to produce consistent and correct code.

Summary: AI is a great helper, but not omnipotent

After several days of hands-on work, my conclusion is:

Things AI is good at:

✅ Clear, repetitive tasks
✅ Development with templates to follow
✅ Quickly producing initial code
✅ Helping with debugging and code review
✅ Integrating automated workflows

Things AI is not good at:

❌ Complex, ambiguous requirement definitions
❌ Development requiring deep understanding of business logic
❌ Completely unsupervised code production
❌ Performance tuning and architecture decisions

The most important mindset shift: don't expect AI to nail it in one go. Treat it like a smart but-needs-guidance Junior/Mid engineer — give clear instructions, review results in chunks, course-correct in time. That's how you extract the most value from AI-assisted development.

Postscript

AI tools are advancing fast — today's limits may be lifted tomorrow. But no matter how powerful the tool, an engineer's judgment and experience remain irreplaceable. Use AI to accelerate development while keeping a watchful eye on code quality — that's the most pragmatic strategy for the AI era.