Last week, we were exhibiting at VivaTech for the first time. It’s a sprawling, well-run event - this year’s stage ran from Jeff Bezos to Narendra Modi to Yann LeCun, a who’s-who. On the floor, AI was on everyone’s lips, and you had to stand out.
At one point, we received the visit of a bank CIO. He was good - the kind of technical that doesn’t perform technicality. He spent twenty minutes taking our AI platform apart: sharp questions about the architecture, sharper ones about what we were doing beyond simple LLM calls.
Then, looking at the interface we’d built, he said it almost kindly:
“Beware of the Claude Effect. Even my fourteen-year-old can make a UI like this with Claude now. The hard part comes after - when it has to actually work. When it has to be solid.”
I nodded. I smiled. And behind the smile, a small voice: what just happened?
Three years ago, that demo was the proof
Three or four years ago, that same walkthrough would have impressed him - not because a screen is impressive, but because it was evidence that behind it stood a team that could actually build.
The demo was never really the point. It was a proxy, a costly signal - valuable precisely because it was hard to fake - that said: these people are capable, you can trust them with the hard thing.
Then the cost of the signal collapsed. A quarter of the startups in Y Combinator’s latest winter batch have codebases that are 95% or more AI-generated. When the polished build is nearly free, it stops proving anything about who produced it.
So now a polished interface separates no one. A capable team’s work and a teenager’s Saturday project can look identical from the outside - one in control of the tool, the other carried by it, but none of that reaches across a stand. So whoever is evaluating you has no choice but to lump them together until proven otherwise.
What used to go without saying
So what actually changed? Not the work.
My team builds the way we always have. We just use these tools to go faster - because we stay in control of them, not the other way round. That is the real divide, and it’s the one the CIO can’t see from across a stand: not who reached for AI, but who stayed in control of it.
What changed is what we now have to prove. Three years ago that capability was assumed the moment the demo loaded - granted on sight, and he’d move on. Now the demo proves nothing, so everything that used to be implicit has to be re-earned out loud - in exactly the twenty-minute interrogation he’d just put us through.
He wasn’t devaluing engineering. He was withdrawing his trust in the shortcut to it.
The Claude Effect didn’t lower what we can do - it deleted the benefit of the doubt we used to be given for it.
The question is no longer “can you build it?” - the screen says yes to everyone. The real one, the one he was asking the slow way: are you in control of this thing, or is it in control of you?
Why the doubt is fair
And his skepticism is earned.
In July 2025, the founder of SaaStr let an AI coding agent run against his project. It worked - until it deleted his production database during a code freeze, then told him the data was unrecoverable. The demo would have looked flawless; the 2am reality was a catastrophe. When Veracode tested over 100 AI models, 45% of the code they produced carried known security vulnerabilities - it compiles, the screen looks right, and somewhere inside sits a flaw nobody reviewed.
What the screen can’t show is the part that was always the real work: the security review, the architecture that survives year two, knowing which corner you cut on purpose. When the thing you ship carries real money - someone’s rent, a payroll, a trader’s float - “solid” was never a finishing touch. It’s the whole job.
None of that is new. What’s new is that it went invisible at exactly the moment it most needs to be seen.
The trap waiting for us
His warning is fair. The trap is in how we answer it.
The comfortable move is to feel superior - “AI makes toys, real engineers make solid systems.” But that is partly a defense mechanism, because the solid gap is closing too: the same tools are getting better at the tests, the hardening, the durable parts. If our whole claim becomes “only we can do solid,” we are resting on a draining moat - and worse, it curdles into gatekeeping. Some of those fourteen-year-olds will be very good.
None of this is new, either. Every abstraction layer - compiler, framework, no-code - commoditized the one beneath it and pushed its people up a floor. AI just did it to the demo itself, the same industrialization of software one conference stand at a time.
So how do we walk in now?
What I walked away with wasn’t about the building itself. It’s that the demo can’t carry the conversation anymore. Whatever credibility the polish used to buy, we now have to earn in the back-and-forth - the trade-off we’d defend, the thing we chose not to build, the judgment made visible.
He wasn’t really talking about our code. He’d put his finger on something I hadn’t noticed: the shortcut to being believed is gone. So when the screen no longer vouches for us, what does?