Building useful products with tiny teams.

There is a strange assumption in software that serious products require serious headcount.

Sometimes they do.

A lot of the time, they require clarity more than people.

AI has made this even more obvious.

A small team can now move through the product development cycle much faster.

Research can be accelerated.

Prototypes can be generated quickly.

Code can be scaffolded.

Documentation can be drafted.

Design variations can be explored.

Testing can cover more cases.

None of this replaces people.

It reduces the amount of mechanical work each person needs to do.

That creates a very different operating model.

Two people with strong product thinking can sometimes move at the speed that previously required a much larger team.

Not because two people magically became ten people.

Because the amount of work between an idea and a testable result has decreased.

But there is a catch.

AI makes execution cheaper.

It does not make bad ideas good.

In fact, cheap execution makes product judgment more important.

When building is expensive, teams naturally filter ideas because they cannot afford to build everything.

When building becomes cheap, that filter disappears.

Now you can build five mediocre products in the time it used to take to build one.

That doesn't mean you are more productive.

You are just producing mediocrity faster.

The solution is stronger product thinking.

Before building, understand the problem.

Before adding a feature, understand why it needs to exist.

Before scaling, prove that someone actually cares.

Tiny teams have an advantage here because communication overhead is low.

A small team can make decisions quickly, build quickly and change direction quickly.

The challenge is knowing when to change direction.

That is where judgment still matters.

AI can accelerate the loop.

It cannot decide what is worth looping on.