the new builders

Two years ago the penny dropped for me. I was at Aiden back then, a consultant in customer experience and CRM, and I got to see up close what enterprise software can do. And just as much, where the wall is. SAP’s rock-solid, don’t get me wrong. Only it’s expensive, it’s no fit for a small company, and you need implementation partners bolted on. And the money that pours into that. Before a project even exists you’ve sat through twenty hours of talking, drawing up documents, sending contracts round. Just like that you’re forty hours deep. Do the sum: five thousand euros. Only to get started.

Around that same time I found out AI could code. So I jumped straight in. Because the functional domain knowledge, that I already had. I knew exactly which sales and service processes a system like that has to carry. What I was missing, the AI handed me. So I set about building my own CRM. For SMBs, for the companies that whole enterprise story was never meant for. That system’s called fikst now.

And honestly? First time round it didn’t work. I started out on Gemini back then, and after a year the thing kind of died on me. I ran into so many errors, and I’d just gone off too fast. First version, first attempt, straight into the wall. So I dropped it for half a year. Did other things in the meantime, smaller agent projects, small clients.

Until somewhere along the way I clocked it: hey, these models are suddenly getting really strong. So a year ago I started over. Took the shell of what I already had and built on from there. And then it went fast. A year of building and testing, not full-time, I didn’t have that kind of time, but serious hours all the same. And what stands now is a proper product. With a first pilot client running it live in production. Living proof that one person, one team, gets further with this than you’d think. I’m not saying it sits at SAP level. It doesn’t have to. That was never the goal.

And that right there is the shift this whole piece rests on. Building software has changed in its composition. And the market I come from, it feels it.

the incumbents get repriced

On June 18, 2026, that same undercurrent slammed hard the other way. Accenture lost about a fifth of its market value in a single day. Worst one-day fall the stock’s ever had. And mind you, revenue had actually gone up, six percent in dollars. But new bookings shrank by two percent, guidance came down, and investors, as Bloomberg reported, read something much bigger into it. The fear that AI is repricing the whole consulting market. Capgemini went down the same day too, more than eight percent, to a 52-week low. And it didn’t come out of nowhere. A year earlier Accenture had already cut over eleven thousand jobs in a restructuring worth some 865 million dollars. On the earnings call, CEO Julie Sweet explained that for a good chunk of the people leaving, reskilling toward the AI skills the firm now needs just wasn’t a road you could still walk.

And on the other side of that same market, the opposite was happening. Fortune told the story of Maor Shlomo, who built the Base44 platform in four months, near enough on his own. It’s a tool that lets non-technical people create software just by describing what they want. First month after launch? Nearly one and a half million dollars in subscriptions. Six months after he founded it, Wix bought the thing for eighty million dollars, as TechCrunch reported. And the same magazine, around the same time, profiled Dana Snyder. A nonprofit consultant with no technical background at all, who built her own software platform in half a year and runs it as its only full-time employee.

Two extremes. And still one and the same movement. What the giants are watching fall away and what those solo builders are watching come into being come out of the exact same shift.

the craft did not get faster, it got different

The hardest evidence we’ve got right now comes from the Anthropic Economic Index. It’s an analysis of some four hundred thousand working sessions, from roughly 235,000 people building with agents, measured from October 2025 to April 2026. Two caveats first, because they matter. Anthropic’s measuring its own users, so this is telemetry from the front of the pack, not a snapshot of the whole market. And “success” in this research just means the conversation got classified a certain way. It’s no proof the result ever reached production.

So what does the telemetry actually show? Not acceleration. A shift. The share of sessions spent repairing broken code dropped from 33 to 19 percent in half a year. Operating and running software went up, 14 to 21 percent. Writing and data analysis roughly doubled, from about ten to twenty percent. Less time on what’s broken, more on what needs to exist. Oh, and there’s no straight line to full automation hiding in these numbers either: between two consecutive samples, the share of automated interactions in API traffic actually dropped sharply.

And anyone who’s ever worked on a team feels straight off what that means. Your classic software project spends most of its calendar not really thinking. It goes on friction. Handovers, alignment, waiting around, repair. An agent takes over the typing, and that friction doesn’t vanish. It moves. So the scarce skill isn’t that you can write code anymore. It’s knowing exactly what needs to come, and being able to see whether what’s there is any good.

domain knowledge beats the diploma

The most striking number in that same research has nothing to do with speed. Anthropic looked at how often people from wildly different occupations finish their building task. And something odd comes out. Every big occupational group, from managers to lawyers to social scientists, succeeds at coding tasks at just about the same rate as the professional software engineers. The whole top ten sits within some seven percentage points of each other. And the more domain knowledge someone brings, the more an agent gets done per instruction.

That’s the real disruption. And a good deal quieter than all those demos on LinkedIn. It isn’t that everyone can suddenly program. What’s shifted is the predictor of success. For decades the first question was: who can build this? And now the question is: who understands this process well enough to steer a system that builds it for them?

And I feel it every day. Look, we don’t really do the hard work anymore. It’s mostly critical thinking now, with a creative mindset. Making architectural calls, giving the AI direction, and reviewing. And that costs way less time than building it yourself, because the building is where all your time used to go. An integration I now put together inside a day, an agency took a week over. Two weeks, with three consultants. I’ve watched thirty people sit on one project up close, a mountain of money burned straight through. And don’t get me wrong, plenty gets delivered there too, those are complex jobs. But on a custom piece like that I just think: I’ll do that in a fraction of the time.

So my value sits less and less in the lines of code I type myself. More and more it sits in those fourteen CRM projects I ran from start to finish. Those taught me how a quote really moves through a company. Where a service process jams. Which edge case is going to hurt you on day ninety. The customer portal I built for Elite Klimaat went live after a month of building, for under five thousand euros. A normal outfit would’ve asked thirty thousand for it. Six times the price, I’ll happily say it. And yeah, a portal like that carries plain enterprise security requirements. Only you safeguard those fine now too, long as you’ve got the right builder and put the right products round it. Because that agentic AI, that’s a tool. Not the product. Put the right shell round it, and you meet those requirements just as well.

And there’s more to it. The feedback loop’s gotten shorter than anything the old world ever knew. Used to be you needed weeks after a session for a first version. Now I’ve got a meeting in the morning, I set up a proof of concept over the break, and we go through it in the afternoon. Visual, a real app on the screen. Look: this for the design, what do you reckon, how about that one? That speed doesn’t just change the tempo. It changes the whole conversation.

the old arithmetic breaks

The old delivery model is a sum: hourly rate times team size times months. And every factor in it is under pressure now. One builder with agents delivers what a whole team used to, and lead times go from months to weeks? Then precious little of that sum survives. A hard, verified number for that gap doesn’t exist yet, by the way. Anyone quoting one is making it up. But the direction’s already in the books: new bookings at Accenture shrank, and the market’s already pricing in the doubt.

And the counterargument earns its place, it really does. Accenture’s own CEO disputes that AI explanation herself. She points at weak demand, at US government spending cuts, at geopolitical unrest. And she lays a number of her own beside it: bookings for deals above a hundred million dollars actually grew, thirteen percent. All of that can be true at once. A share price measures fear, not proven cause. Sure. And still. A sector that rebuilds itself around AI skills, that lets thousands go, partly because reskilling doesn’t work anymore, and that gets repriced by the market on AI fear: that’s not behaving much like a sector that thinks nothing’s up.

the downside the pioneers prefer to skip

And a warning belongs here. Leave it out, and you’re selling somebody something. And I’ll start with myself, because I fell for it, badly.

I was setting up the complex route logic, with Google Maps’ dynamic-routing API. And while I was testing I hadn’t put a limit on it. I let my agent test autonomously, an improvement loop running underneath, and it just kept recalculating. Result: a bill of a thousand euros in test traffic. That model was a lot more expensive than I’d figured. And the AI hadn’t done it on purpose, mind. It just wanted the best and the fastest solution, and cost efficiency it hadn’t thought about for one second. That’s the typical thing. AI loves to go for the easy, fast solution, and sometimes that’s simply the wrong one. You’ve got to be able to see it coming. And that instinct you only get from working with these things a whole lot, plus the IT knowledge, plus the functional knowledge. Put no cap on what an agent spends, and it can cost you a thousand euros just to find that out.

And it isn’t only me. Security firm Veracode threw more than a hundred language models at eighty coding tasks. In 45 percent of the AI-generated code there was a known vulnerability, and that figure’s been basically flat for two years. Give a model the choice between a safe route and an unsafe one, and it grabs the wrong one about half the time. Now, it’s a benchmark from a vendor with a stake in the outcome, so read it as direction, not a final score. Fair. But the direction gets confirmed elsewhere too. A study of 302,600 verified AI commits across more than six thousand GitHub projects, shared as a preprint and not yet peer reviewed, found that for every tool tested, more than fifteen percent of commits introduce at least one demonstrable issue, that AI commits add one and a half times as many security problems as they fix, and that nearly a quarter of those issues were still unresolved at the last measurement. Technical debt, at machine pace. And then there’s Daniel Stenberg, the man behind curl, software that runs on billions of devices. He shut down his bug bounty program early in 2026 after six years: a fifth of submissions had gone AI-generated, each one could cost three or four reviewers hours of work, and not a single AI submission ever turned up a valid finding. Not one.

And this is exactly why speed on its own proves nothing. AI lowers the barrier to building. It does not lower the barrier one millimeter to building something that’s actually sound. Strip out the craftsmanship and the new way just makes the same mistakes as the old one. Only faster, and in far bigger numbers. So I treat everything an agent hands me as a suspect first draft. MIT researchers who dug into why enterprise pilots stall land in the same place: it’s rarely the model that fails, it’s the organization that never learns how to build with it. I wrote about that gap between demo and service earlier, in the production gap. And how sturdy those failure numbers are themselves, that I weigh separately in the 95 percent myth.

and if you hire one

Say you do bring one of these builders in. Then there’s one risk that towers over the rest: continuity. That one person drops out, and your project stalls. Software teams call it the bus factor, and with a solo builder the answer’s one, by definition. You don’t cover that with trust, you cover it with a handful of agreements. A good builder brings them up himself, mind.

Ownership sits with you from day one: code, prompts, configuration, all of it in your repository, your accounts, your domain. You’ve got to be able to pull the builder’s access, never the other way round. Documentation’s a delivery requirement, not an extra: with every handover a decision log of why it’s built the way it is, plus a short walkthrough. No docs, no acceptance, no payment. And then the requirement most builders skip, the one I rate highest myself: get any other developer to have the system running inside a working day off the documentation alone, and actually test that at least once. A handover that’s never been tested doesn’t exist. Build on standard parts thousands of people know, not some exotic stack only the builder still gets. Put maintenance and exit on paper, with the name of a stand-in. And pay per delivered, working step, so your worst-case damage if they drop out is one step. A builder who waves those risks away? That alone is a reason not to go with them. You want to hear the opposite, that they name them and lock them down.

who the new builders are

Add it all up and a profile takes shape. The new builders aren’t big teams with an AI license bolted on. And they’re not prompters without a craft either. They’re small, senior builders who’ve got two things at once: domain knowledge that runs deep enough to steer a system, and the discipline to distrust machine work. For me the order’s fixed. Specification first, then build. Agents that check each other’s work. And no change goes live before it’s been tested. And because those methods shift again every month, a serious chunk of my time, for me roughly half, goes into keeping up. Trying out what proves itself, and leaving the rest.

By now I genuinely see myself as a disruptor. Of the market I came out of, too. Not because that market’s worth nothing, quite the opposite, I learned everything I use now right there. But because the composition of the work has changed, and the market’s repricing that old sum while we watch. And with that, the question you’ve got to ask the moment you have something built shifts too. No longer: does my supplier use AI? Come on, everyone does that by now. The question that counts is whether there’s someone at the wheel who genuinely gets your process. Someone who checks every change before it goes live. And who’s still there when the system suddenly behaves differently on day ninety than it did in the demo. Ask that question, and you’ll spot the new builders on your own.