We were three days from wiring $300,000 to a team of engineers. The job: write custom Python to rip diagrams and specs out of a stack of technical troubleshooting guides. Scoped, quoted, ready to sign.
Then ChatGPT got vision. Overnight, the thing we were about to pay six figures to build was a checkbox in a tool we already owned.
We didn’t sign. We tested it against our own guides, and never wrote the check.
That decision took a day. Two years earlier it would have taken a quarter, and by the time we’d scoped it, socialized it, and justified it, we’d have paid full price for something that no longer needed building.
That’s the shift. Building used to be the slow, expensive part, so the discipline was to plan once and protect the plan. Now building is nearly free. The scarce thing is deciding fast enough to keep up with what just became possible.
The same speed that killed that $300,000 spend is the speed this new engineering world runs on. Here’s what it looks like pointed at building instead of killing.
Four hours to rebuild what took a year
One of our engineers built a new facilities platform in three months. Modern stack, clean architecture. The platform it’s built to replace took an army of engineers, years, and millions of dollars to build.
Behind that build was a decision that sounds small and isn’t: no more upgrades. No version upgrades of old software. When something hits its limit, you don’t patch it forward, you rebuild it modern. That was the mandate from our CTO.
Here is where it got tested. We ran a system that scheduled every preventative-maintenance work order in the business. We were mid-consolidation on a company we had acquired, moving thousands of PMs into it, when we hit a wall. Not a performance problem. A hard internal limit that stopped us from adding any more work orders. The kind of thing that used to mean a long, careful version upgrade. Months of it.
The engineer knew the mandate. So instead of the upgrade, he pointed an AI agent at the old system and tried to rewrite it on the new platform’s stack. What the hell, let’s try. Four hours later, the prototype was working. Four hours to rebuild a platform that took a year to build a decade ago. Tested, vetted, and in production about a month later, on a system scheduling real work orders that generate revenue. And the code held up, because the team had taken the time to build their standards into the coding agents. The speed didn’t cost quality. The standards were baked in.
That four hours only happened because we had stopped patching the past. The mandate forced the rethink. A culture that told the engineer to take the swing did the rest. Mandate plus permission to try. That combination produced it, not the tool.
Then the speed compounds. What used to be a two-week sprint for a pod of engineers is now a few hours for one engineer and a swarm of agents. Epics that used to run multiple sprints across multiple teams, months of work, now land in an afternoon, or overnight while everyone is asleep.
And that is where the real problem shows up, and it is not a technology problem. It is a planning problem. When your engineers can clear months of roadmap in a week, they run out of work long before your next planning cycle. Quarterly and annual planning rhythms cannot feed them fast enough.
I was at the Cursor Preview event the night before their first Compile conference, the same night before the SpaceX acquisition was announced. A CTO from a major-brand software house said the same thing out loud: his teams were running out of work before the next planning cycle. This is a live problem for people running serious engineering organizations right now.
The bottleneck moved. It walked out of the codebase, past the engineering teams, and straight into the C-suite planning office.
Speed is already taking the customers
You don’t have to imagine this. It’s on the scoreboard right now. Jira has owned developer project management for two decades. A challenger called Linear is taking the new customers anyway, and it’s doing it on speed and AI-native integration. It works with the new agent harnesses almost intuitively.
A year ago it wasn’t close. Jira was signing up nearly three new companies for every one Linear landed. Twelve months later they’re within about twelve percent of each other, and Jira’s new-customer count is falling while Linear’s climbs. To be fair, Jira isn’t dying. It’s still a machine that books over a billion dollars a quarter and serves the Fortune 500. But the bigger, richer, everywhere incumbent is losing to the upstart that’s willing to move fast and fully integrate the new AI-first tools.
Why? Linear is fast. It decides for you and gets out of the way. Jira makes you configure your way to a decision. And it’s built for how the work happens now: an issue drops into an agent’s workflow and comes back done, with a human in the loop. When two products cost about the same to build, speed and native AI fit pick the winner. The teams choosing Linear aren’t fringe. OpenAI, Scale AI, and Perplexity run on it. The next generation of builders is growing up deciding fast, and they aren’t going back.
Here’s the part that should scare an incumbent. Startup speed wired to AI doesn’t chip away at your customer base over a decade. It takes the next customer this quarter. Fast.
Microsoft had everything and missed anyway
Now the case that kills the excuses. Microsoft had the technology, the OpenAI partnership, distribution into every company on earth, and more money than God. It still came out behind in AI coding.
Here’s the read. Microsoft shipped Copilot before it was ready, priced it for a promise it couldn’t yet keep, and leaned on the brand to carry it. The market noticed. Salesforce’s CEO called it “Clippy 2.0” in public and said customers weren’t getting value. Anyone who used early Copilot, me included, knows he wasn’t wrong. And the doubt wasn’t only outside the building. Reporters read the internal emails and talked to the people building it, and it was real. And here’s the number that actually matters: of the companies that finished piloting Copilot, only about one in twenty moved it into real deployment. Pilots aren’t progress. Deployment is.
The market delivered its verdict in the two languages that don’t lie. Microsoft cut its entry price to get people in the door, and a regulator in Australia forced it to refund customers over how it pushed the AI onto them in the first place. Price and enforcement. Those don’t lie.
They came to market a year and a half to two years late. And none of it was a resource problem. Microsoft had every resource there is. What it couldn’t do was decide, fast, to disrupt its own stack before someone else did. That’s the whole lesson. Money does not save the company that cannot decide.
The best players don’t win the race. They redefine it.
Someone did decide. Cursor, the company from that same preview event, took Microsoft’s own code editor, forked it, and four people out of MIT shipped a new thing in 2023. Then the revenue took off. From roughly $100 million to past $2 billion in about two years, the fastest ramp software has ever seen. The last generation of giants took years to reach their first billion.
The money is not the point. Three things are.
First, what Cursor sold. It didn’t build a better editor. It baked AI-driven development into the tool, made it easy, and let developers run whatever AI model they wanted. Choice. Every engineer loves choice. It stopped fighting over editor features and became the place you build with agents, built on top of the incumbent’s own product. Speed didn’t just win the race. It moved the finish line.
Second, how Cursor built. It ships features at a pace the incumbent can’t touch, because everyone there is a builder using AI to write the code. The speed isn’t a trick. It’s an org where building is the default state of every person in it.
Third, how Cursor evolved. It never needed a finished product to win. It shipped early, listened hard, and rewrote itself at the new speed of AI engineering, fast enough that every release was proof it was hearing its users.
That’s the tell for where this goes. The companies that win won’t be the ones that bought the tools. They’ll be the ones where everybody builds, and everybody listens.
Fast is not the same as reckless
Here’s the fair objection. Move this fast in a serious company and you’ll blow something up. A P&L, a regulator, a reputation. It’s the right thing to worry about, and it’s the reason most operators talk fast and move slow.
So look at the places where the stakes are highest, because they aren’t hiding from AI. They’re governing it. The big audit firms now test an AI agent the way they test any other control: adversarial prompts, stress tests, tracing the data, before and after it goes live. Deloitte has gone further and embedded a network of audit agents into its own platform, with human oversight built in. ISACA, the body that certifies auditors, already wrote the standard for it and a credential to match. Darktrace has run AI-driven cyber defense on critical infrastructure since 2013, including the control systems of one of the largest power stations in Britain. More than a decade of AI trusted to defend the systems that keep the lights on. And when the financial regulator faced generative AI, it didn’t ban it. FINRA said plainly that its supervision rules apply to AI the same as any other tool, and told firms to govern it.
That’s the whole discipline in one line. Audit the agent like any other control. You move fast where you can, and you prove the machine is governed. That isn’t cowboy. That’s disciplined aggression, and there’s a difference.
The job now
The old job was to protect a plan. When building was slow and expensive, that was the right job, and the people who did it well won for thirty years. Most of us were trained on it. Scope it, socialize it, defend it.
That job is over. Build is nearly free, so the plan is not the asset anymore. The asset is a team that decides fast, builds by default, and can prove it stayed inside the lines. The routine belongs to the machine now. The judgment that matters belongs to a human. The one who wins from here isn’t the one with the biggest plan or the biggest budget. It’s the one who can tell a call worth making today from one worth killing, and then actually makes it.
Build is free now. Deciding isn’t. That’s the whole game.