There is an old story about Christopher Columbus and an egg. After his voyage, some noblemen supposedly told him that what he had accomplished was not so extraordinary. If he had not done it, surely someone else would have.
Columbus asked them to make an egg stand upright. They tried and failed. He then tapped one end of the egg on the table, flattening it slightly, and stood it up. Naturally, everyone complained that this was obvious.
Exactly.
That is the point.
The story is probably not literally true. It appears in Girolamo Benzoni's Historia del Mondo Nuovo, published in 1565, decades after Columbus died, and similar anecdotes had already been associated with Filippo Brunelleschi and the dome of Florence Cathedral. But as a metaphor for invention, it has survived for a reason: once a difficult problem has been solved, the solution often looks embarrassingly simple.
AI is making that effect much stronger.
For most of software history, implementation was expensive enough that we tended to confuse the difficulty of building something with the difficulty of conceiving it. A feature that required six months of work looked important partly because six months of work had gone into it. A complicated subsystem with tens of thousands of lines of code looked impressive partly because producing those lines required a lot of human effort.
That relationship is breaking down very quickly.
With modern coding agents, once the problem is well understood, the architecture is clear, the constraints are known and the agent has access to the repository, documentation, compiler and tests, implementation can become astonishingly cheap. Work that once took weeks can sometimes be completed in hours.
And this creates a new version of the Columbus Egg problem.
Someone sees the finished feature, reads the code and says: "That was easy. I could have done that with AI."
Yes.
Now you could.
The interesting question is why you did not do it before seeing the answer.
That distinction is becoming increasingly important because AI is making code itself less scarce. The scarce resource is moving upstream: identifying the right problem, finding the right abstraction, understanding which constraints matter, choosing an architecture that will still make sense three years from now, and recognizing opportunities that everyone else has been staring at without seeing.
AI can help with all of these things, of course. But the fact that an agent can implement an idea cheaply does not mean the idea itself was obvious.
At Ice Tea Group we see this constantly with Wisej.NET. AI agents can now implement changes that would once have required highly specialized knowledge and a great deal of time. But they can do that partly because decades of architectural decisions, conventions, APIs, compatibility requirements, tests and accumulated engineering knowledge already exist in the system.
Once all that context is available, execution can be extremely fast.
To someone looking only at the final patch, the result may appear trivial. It may be a few hundred lines of code. It may even be something an AI agent can reproduce in an afternoon.
But the implementation is only the visible end of a much longer chain of reasoning.
This is also why AI does not make expertise irrelevant. It moves the value of expertise. Twenty years ago, a senior engineer's advantage was partly that he could personally perform difficult implementations faster and more reliably than someone less experienced. Increasingly, that implementation can be delegated.
The senior engineer's leverage moves toward knowing what should be built, recognizing when an apparently elegant solution is wrong, understanding the consequences of a design decision, and giving the agent the context that allows it to operate correctly.
The typing was never the most valuable part of software engineering. It was simply unavoidable.
AI is removing more and more of that unavoidable work.
And something else happens when implementation becomes cheap: experimentation becomes cheap too.
If testing an idea costs six engineer-months, you naturally become cautious. If testing it costs an afternoon, you can afford to try ten ideas, discard nine and keep the one that works.
That may ultimately be one of AI's biggest effects on software development. Not that every idea gets implemented faster, but that far more ideas get a chance to exist.
Which brings us back to Columbus and the egg.
The clever part was not the physical act of standing up the egg. Once you saw it done, that part was trivial. The clever part was seeing a different way to think about the problem.
AI is rapidly making implementation the cheap part.
That means we should expect to hear "I could have built that" more and more often.
And the correct answer will often be:
Of course you could. Now.