Where AI Is Amazing

In the previous articles, I explored how AI is changing my role as a developer, and how vibe coding introduces both speed and risk.

But it’s easy to focus too much on the downsides.

Because there are areas where AI is simply… very good.

Not perfect. Not magical. But consistently useful to the point where it changes how I work day to day.

Not Everything — But Some Things Really Well

AI isn’t equally good at every part of software development.

But it tends to perform well when:

• The problem is well understood
• The patterns are common
• The structure is predictable

In those situations, it can remove a surprising amount of friction.

Finding the Right Words

One of the first things that stood out to me wasn’t code. It was documentation.

Writing documentation has always been one of those tasks I postpone. Not because it’s hard, but because it takes time to find the right words.

AI is surprisingly good at that.

• Turning rough notes into clear explanations
• Writing inline comments that actually explain intent
• Generating README files that are structured and readable

It turns documentation from a 'chore for later' into a 'side effect of now.' By providing the first draft, it shifts your job from Author to Editor—a much lower cognitive hurdle.

Instead of staring at a blank page, you refine something that already exists.

Writing Tests That Actually Help

Another area where AI consistently helps is testing.

Writing unit tests, improving coverage, and thinking through edge cases can be time-consuming, especially when dealing with more complex logic.

AI is very effective at:

• Generating unit tests for a specific feature
• Creating both success and failure paths
• Suggesting edge cases you might not immediately think of
• Mocking dependencies or services

What works particularly well is that tests usually have a limited scope. You’re not asking AI to understand your entire application, just a single piece of behavior.

That keeps the context manageable — and the output surprisingly useful.

It’s not always perfect, but it’s often a very strong starting point.

Scaffolding Ideas Into Reality

Where AI really starts to feel powerful is when building something new.

I’ve used it to scaffold packages or features by describing:

• The problem
• The intended use
• The preferred code style

From there, it can generate a solid starting point:

• Basic structure
• Initial implementation
• Tests
• Documentation

When you define the style and the problem, you’re giving the orchestra the 'key' and the 'tempo' before they play a single note.

And then comes the real workflow: incremental improvement.

You refine the code.
You adjust the structure.
You add missing pieces.

AI becomes part of the loop, not the final authority.

But Stay Vigilant

Even in these “strong” areas, the same rules apply.

You still need to:

• Watch the architecture
• Keep things readable
• Think about performance
• Question assumptions

AI can get you to a working solution quickly. But whether that solution is good in the long term is still your responsibility.

The Orchestra at Its Best

This is where the orchestra metaphor fits best.

Some sections can play almost effortlessly.

You don’t need to guide every note. You don’t need to correct every detail. The music comes together quickly, and often sounds good.

Documentation, tests, scaffolding — these are the sections where AI plays well with minimal direction.

Other parts still require careful listening and guidance.

Where This Leads

Once you start using AI in these areas, it becomes hard to go back.

Not because it replaces your work, but because it removes the parts that slow you down without adding much value.

And that leads to a bigger question.

If AI is this good at producing working software…

What happens when the cost of building software drops even further?

In the next article, we’ll look at how AI is changing the economics of building software — and what happens when creating something becomes cheap.

Let’s explore!