AI Didn't Just Speed Up Software. It Changed What's Possible.

TL;DR: AI didn't just make developers faster - it made small teams capable of building what used to require entire engineering departments. But speed without domain expertise is just expensive chaos. The teams that combine AI-native development with real industry knowledge will build what comes next.

A team of four recently shipped a hire purchase management platform - loan origination, payment tracking, collections workflows, the works. About four months from zero to production. Not a prototype. Not an MVP with asterisks. A real system processing real contracts for a real automotive finance company.

Two years ago, that same project would've taken a team of fifteen and the better part of a year.

The difference isn't that we found better engineers. It's that the tools changed what a small, experienced team is capable of building.

What Actually Changed

I've been writing software since 2003. I've watched the tools evolve from vi and makefiles to modern IDEs, and every generation felt like a meaningful step forward. But nothing - nothing - compares to the shift of the past three years.

In 2023, AI could autocomplete lines and generate small functions. Useful, but incremental - the "tab to complete" era. By 2024, it could understand entire files, do simple refactoring, write reliable code given context. Still a tool, though. A fast one. 2025 was the inflection point - AI development agents went mainstream, able to understand an entire codebase, reliably edit multiple files, and work task by task. Now in 2026, we're entering the era of objective-by-objective - long-running agents that understand the entire project and can write out whole objectives across it.

The real shift isn't that existing developers got faster. It's that small teams can now build what used to require large ones.

At Carro, we spent a decade and millions of dollars building out our systems - CRM, fleet management, inspection apps, credit management, auction systems, inventory, dispatch, leasing, ERP. Hundreds of engineers across six countries. What we built in ten years could now reasonably be built in a fraction of the time and resource.

Not because AI writes perfect code - it absolutely does not. We've had situations where the same logic ended up in three different files, and when you ask the AI to change something it updates one file but doesn't find the other two. You only discover this after things start breaking and you go read the code yourself. AI-generated codebases accumulate dead code and duplication in ways that human-written ones typically don't.

The gain is that AI eliminates the boring parts. Boilerplate. Test scaffolding. Documentation. Migration scripts. The stuff that used to eat most of an engineer's week. Strip that away and suddenly a small team of experienced people can focus entirely on the hard problems - architecture, business logic, edge cases.

Speed Changes the Game

This isn't just about building faster for its own sake. Speed fundamentally changes the kind of software you can build.

When a project takes 18 months, you're locked into decisions you made in month one. Requirements change. Markets shift. By the time you ship, half the assumptions are wrong - that's why so many enterprise projects deliver something nobody wants anymore.

When you can go from concept to production in months instead of years, you can iterate in the real world instead of in a spec document. You build, put it in front of users, learn, and adjust. The product gets shaped by reality, not by a requirements document that's six months stale.

For industries that have never had purpose-built software - because it would've taken too long and required too large a team - this is a completely different equation. It's not that the software got cheaper. It's that it became possible to build it with a team small enough to stay close to the problem.

Why Expertise Matters More Now, Not Less

Here's what the hype cycle gets wrong: AI doesn't replace expertise. It amplifies it.

Give AI tools to an experienced engineer who understands the domain and you get remarkable output. Give the same tools to a junior developer who doesn't understand the business problem and you get code that compiles, passes tests, and completely misses the point.

I think most companies are still grappling with how to get real returns from AI. The ones that do well aren't just adopting AI tools - they're pairing those tools with people who know what to build, not just people who can build fast. Speed without direction is just expensive chaos.

This is why we pair AI-native development with deep operational experience at First To Fly. The AI handles velocity. The operator experience handles direction. You need both, or you're just producing bad software faster.

The Window

Right now, there's a window. Industries across Southeast Asia - logistics, clinics, dealerships, construction, food supply chains - are running on manual processes and generic tools. The vertical software they need can now be built by small, focused teams who actually understand the industry.

I think the teams that combine AI-native development with real domain expertise will build the next generation of industry software. Everyone else will be reading about it in a case study two years from now.

That's the thesis behind what we're building at First To Fly. The capability shifted. The question is who moves first.

Start a conversation.