AI IDE, Code Agent, and Vibe Coding

How Should We Write Code in This Era?

Over the past year, my approach to development has fundamentally changed.

I no longer just write code; instead, I collaborate with AI. From traditional IDEs to AI IDEs, and then to the emergence of various Code Agents, I am rethinking the very nature of what it means to be an “engineer.”

I use AI every day now. Not just for assistance, but for collaboration.

This isn’t merely an efficiency boost; it’s a shift in working paradigms and ways of thinking.

AI is Redefining Software Engineering

More and more developers are starting to use AI IDEs, such as: GitHub Copilot, Cursor, Claude Code, OpenAI Codex, Google Antigravity.

The changes brought by these tools go far beyond just “writing faster.”

AI is no longer just autocomplete. It can understand requirements, assist with architectural design, implement features, and even proactively suggest improvements.

Therefore, I have gradually come to believe:

The bottleneck of software engineering is shifting from “implementation capability” to “problem definition and system design capability.”

The engineers of the future will not just be people who write code, but people who:

• Can define problems
• Can design systems
• Can manage complexity
• Can collaborate with AI

Vibe Coding is Not Laziness; It’s a Paradigm Shift in Engineering

When Andrej Karpathy introduced “Vibe Coding,” it sparked considerable discussion and skepticism.

Some believe it represents a decline in engineering quality, while others see it merely as a short-term technological trend.

But in my practical experience, Vibe Coding is not about abandoning engineering; it’s about reallocating the focus of engineering.

We no longer write programs line by line; instead, we use language, abstraction, and high-level thinking to guide AI in implementation.

In this paradigm:

• Prompts are the new expression tools
• Specifications are the new architectural designs
• Thinking capability and system perspective are more important than syntax

True value no longer lies in “how much syntax you can remember,” but in whether you can clearly understand problems and design solutions.

My Understanding of Vibe Coding: Establishing a Controllable Development Process Amid Uncertainty

Vibe Coding is often criticized for being unrigorous or uncontrollable. These concerns are not unfounded.

If we simply hand vague requirements to AI, it can indeed lead to system chaos, technical debt accumulation, and even decreased maintainability.

But I believe that the core of Vibe Coding is not random development, but rather:

Under highly uncertain conditions, establishing a controllable and stable system step-by-step through rapid iteration and continuous validation.

Software development is inherently fraught with uncertainty. Incomplete requirements, unpredictable user behavior, and risks in technology selection.

In the past, we tried to mitigate risks through extensive documentation and upfront design. But in practice, these risks were often merely postponed.

The emergence of AI allows us to touch the real system earlier and validate assumptions in a short time.

Therefore, Vibe Coding is closer to an experimental and feedback-driven engineering approach.

Rapid Alignment of Intent and Outcome

I would define Vibe Coding as:

Using AI to drastically shorten the distance between “Intent → Implementation → Feedback.”

In traditional workflows:

Idea → Design → Implementation → Testing → Fixes → Outcome

Every stage comes with time and communication costs.

AI enables these cycles to be completed rapidly.

I can:

• Quickly convert requirements into an executable system
• Immediately observe actual behavior
• Discover design issues early
• Continuously refine the architecture

This is not about ignoring design, but about bringing design and implementation closer together.

Rigor Hasn’t Disappeared; It Has Shifted

Vibe Coding is often misunderstood as lacking rigor.

But I believe that rigor has simply shifted to different levels.

In the AI era, rigor is no longer just about:

• Whether documentation is complete
• Whether the architecture is done right the first time

What is more important is:

• Whether we are continuously validating assumptions
• Whether we have established automated testing
• Whether we possess rapid rollback and refactoring capabilities
• Whether we can effectively manage system complexity

The focus of engineering has shifted from “predicting the future” to “rapid correction.”

This aligns with agile development and lean startup philosophies.

For instance, as Eric Ries proposed in The Lean Startup:

Build → Measure → Learn.

In the AI era, the speed of this cycle has been vastly accelerated.

Iterative Spec: More Important Than Perfect Design

A common notion on the internet is:

As long as you write a complete spec upfront, you can have AI generate the ideal product in one go.

I believe this is an overly idealized view.

The nature of a product is exploration, not design.

In practice:

• New requirements often emerge only after implementation
• User feedback changes the direction
• Architecture evolves along with the product

Therefore, I prefer:

👉 Iterative Spec.

My workflow is usually:

1. Define a preliminary direction
2. Let AI produce the first version
3. Actually use it
4. Collect feedback
5. Adjust the spec
6. Iterate continuously

This keeps the product closer to true needs.

AI is Lowering the Cost of Trial and Error

In the past, the cost of architectural mistakes was very high. Rewriting a system required a massive amount of time and resources.

Now:

• AI can generate quickly
• We can refactor quickly
• We can compare different solutions quickly

This makes product development more like scientific experiments rather than one-off engineering construction.

In the Future, Everyone Will Need the Ability to Collaborate with AI

Just as in the past:

• Search skills
• Excel
• Presentations

were basic skills.

In the future:

• Collaborating with AI
• Defining problems
• Designing workflows

will become the new digital literacy.

People who don’t know how to code will also be able to create products.

The real gap will come from thinking and system design capabilities.

My Belief

AI is not replacing engineers; it is amplifying engineers.

The strongest people in the future won’t necessarily be the ones who write code the best, but those who can clearly define problems and design systems.

Engineers will transition into:

• Product Builders
• System Designers
• AI Collaborators

The technical barrier is lowering, but the thinking barrier is rising.

This is the direction I will continue to explore and share moving forward.