Software that ships itself: what self-driving apps mean for your roadmap

For most of the past two years, AI in software meant autocomplete in the editor. A model suggested the next few lines, and the rest of the work (designing, testing, reviewing, deploying, fixing what broke at 2am) stayed firmly human. That boundary is now moving. At Vercel Ship London, two sessions mapped the same shift: “Software that ships itself: self-driving apps” from Malavika Balachandran Tadeusz of Vercel, and “Ship Faster with Codex and Vercel” from Romain Huet of OpenAI. The through-line is that AI is spreading across the whole software lifecycle, not just the writing of code. The question for anyone planning a roadmap is no longer whether to use it, but where it genuinely helps today and how to adopt it without quietly lowering your standards.

AI is moving across the whole lifecycle

Code generation was the first beachhead, but it is now the least interesting part. The work that surrounds writing code is where AI is spreading fastest, because that work is repetitive, well-specified, and tedious, exactly what models are good at:

• Code generation from a plain-language brief: scaffolding a feature, route, or migration rather than a single line.
• Automated review that reads a diff and flags the obvious problems (unhandled errors, missing validation, a leaked secret) before a human looks.
• Test writing, generating the coverage engineers routinely skip under pressure.
• Self-healing fixes, where an agent reads a failing build, traces the cause, and proposes a correction.
• Automated pull requests that bundle the change, the tests, and an explanation, ready to approve.

Each existed in some form before. What is new is that they are becoming a connected loop rather than isolated tricks: a tool can write a change, test it, open the PR, and respond to review comments, with the engineer steering instead of typing.

“Self-driving apps”: what is real, what is hype

The phrase “self-driving apps” is deliberately ambitious, and the borrowed analogy is honest about its limits. The genuinely usable version today is software that handles a narrow, well-defined job end to end, and knows when to stop. Vercel framed one such job as deflecting up to 90% of support tickets with an agent: a bounded task, with a clear success signal and a clean escalation path to a human for the rest. That is real, and you can ship it now.

The hype is the leap from “handles a bounded task” to “runs the business unsupervised”. An app that silently rewrites its own logic in production, with no review and no rollback, is not autonomy: it is an unbounded liability. The useful mental model is the same one driving uses: assisted today, supervised tomorrow, and fully autonomous only inside domains narrow enough to trust. Most of the value right now sits in the first two tiers, where a system proposes and a human disposes.

The human bar matters more, not less

When generating a plausible change becomes nearly free, plausible stops being the bar, and the scarce skills shift up the stack. Deciding what to build and why, choosing an architecture that will not collapse under its own success, and knowing which of three working solutions is actually right: these get more valuable, because a model will happily produce confident, well-formatted code that is subtly wrong, and someone has to catch it.

Taste and judgement are the new constraint. An agent can write a hundred tests, but not tell you which behaviours matter to your users; it can refactor a module, but not decide whether the module should exist. The engineers who get the most out of these tools read every diff with real attention and treat the AI as a fast, tireless, occasionally overconfident collaborator, never an oracle.

Governance: keeping velocity from becoming risk

More change landing faster only helps if the change is safe. The guardrails are not new: they are the same engineering discipline that always separated a healthy team from a fragile one, applied with more rigour because the volume is higher. The difference is that these gates are now non-negotiable rather than nice-to-have:

• CI guardrails: type checks, linting, builds, and security scans every change must pass before it can merge, whoever or whatever wrote it.
• A real test suite that encodes the behaviour you care about, so a confident-but-wrong change is caught by a red build rather than a customer.
• Review gates: human approval on anything that touches data, money, auth, or infrastructure, with previews to see the change before it ships.

With those in place, AI-generated work is held to exactly the same standard as human work. That is the whole point: the bar stays where it is, and you simply reach it more often.

How Inteeka uses this in practice

We build on the same modern stack as Vercel Ship (Next.js and the AI SDK on Vercel, with frontier models like Anthropic's Claude), so this is not theory for us. Tools such as Claude Code, Codex, and the Vercel Agent let a small team operate with the leverage of a much larger one: drafting features, writing tests, reviewing diffs, and proposing fixes for failing builds. The agents do the volume; we keep the judgement. Every change still runs the gauntlet of CI, tests, and human review before it reaches production, so speed never comes at the cost of the quality line. That is what we mean by turning the AI conversation into production-grade systems.

What it means for your roadmap

The practical effect is a compression of the distance between an idea and something running in production. Iterations that used to take a sprint can take a day, which changes what is worth trying: smaller bets, more of them, with faster feedback. Leverage per engineer rises, so a lean team can credibly own a roadmap that would once have required hiring. And the bottleneck moves from implementation to decision-making: figuring out what is worth building, and being honest about what good looks like.

The teams that win with this will not be the ones that adopt the most tools. They will be the ones that pair faster iteration with an unmoved standard for quality: letting AI ship the volume while people hold the bar. Plan your roadmap around that combination, and self-driving software becomes an accelerant rather than a hazard.