What Is Autonomous Development as a Service (ADaaS)?

Every “as a Service” has done the same thing. SaaS productized software so you stopped buying CD-ROMs. PaaS productized application platforms so you stopped racking servers. IaaS productized infrastructure so you stopped buying hardware at all.

Each one moved a layer of the stack from a thing you built to a thing you rented. Each one looked, to the people running the prior layer, like a strange and possibly bad idea. Each one absorbed an entire industry inside a decade.

ADaaS is the next one. Autonomous development as a service productizes the engineering practice itself, the pipeline, the harness, the verification loop, the documentation system, the whole apparatus that lets you point at a goal and get shipped software. You don’t rent a tool. You don’t rent a model. You rent a process.

This post defines the category, separates it from the things it gets confused with, and lays out a buyer’s framework for evaluating ADaaS providers, including how to evaluate the one we’re building.

The lineage

Pull the thread on every -aaS and you find the same arc.

SaaS turned software from a thing you bought (in a box) into a thing you logged into (in a browser). The category cracked open in 1999 with Salesforce and now houses ~$300B in revenue across thousands of companies. The unit of consumption became “a seat per month” instead of “a license forever.”

PaaS turned application infrastructure from a thing you assembled (Apache + MySQL + your own load balancer) into a thing you deployed to (Heroku, Vercel). The unit of consumption became “an app” instead of “a stack.”

IaaS turned the hardware itself from a thing you owned (a rack in a colo) into a thing you spun up (an EC2 instance). The unit of consumption became “an hour of compute” instead of “a server lease.”

Now look at what’s actually been left out of those layers: the engineering practice that turns intent into shipped software. That’s still a thing every company builds for itself, with hired engineers, against a backlog. It’s the largest unproductized layer left in the software value chain.

ADaaS is what productizes that.

The unit of consumption becomes “a ticket shipped” instead of “an engineer-week.” That’s a category-defining shift. If the pattern holds, and the underlying economics suggest it will, most software companies in 2030 will buy this layer instead of building it, the same way most software companies in 2010 stopped racking servers.

What you’re actually buying

People hear “autonomous development as a service” and assume it’s an AI coding tool with a marketing team. It isn’t. The category is bigger and more boring than that.

When you buy ADaaS, you’re buying:

A configured agent cluster. Not Claude or GPT, the cluster on top, with the bash harness, the worker pool, the parallelism management, the timeout enforcement. The thing that turns a non-deterministic model into a deterministic teammate. (Why this matters →)

A verification loop. A browser MCP that knows how to spin up your dev server, navigate your routes, take screenshots, read console logs. Without this, the agent’s writing code and hoping. With it, the agent’s writing code and checking.

A context-engineering apparatus. A CLAUDE.md you don’t have to write from scratch. An auto-load table that knows what to load when. Sub-agent definitions for the parts of your codebase that need their own attention. (The discipline behind it →)

A documentation system that builds itself. Every successful ticket writes its own docs. Tomorrow’s tickets are smarter than yesterday’s because the system never forgets a lesson it already paid to learn.

A maintained MCP fleet. Stripe, GitHub, Cloudflare, Loki, your database, all wired up, all kept current, all hardened against the failure modes the provider has already encountered.

A self-healing pipeline. Errors in production trigger autonomous fixes. The on-call rotation goes empty. PagerDuty escalations stop happening because the cluster is faster than the page would have been.

An eject mechanism. This one matters. The whole stack should be portable, your code lives in your repo, your data in your buckets, your secrets in your vault. If the provider raises prices into a corner, you take your code and walk. ADaaS without an eject mechanism is platform lock-in disguised as a service.

What you’re not buying:

A model. The model is upstream of the cluster. You’re buying the apparatus that uses the model.
A code generator. Code generation is one tool call inside the pipeline. The pipeline is what makes generation reliable enough to ship.
An IDE. ADaaS is unattended by definition. There’s no human in the inner loop, so there’s no IDE in the inner loop either.
A no-code builder. ADaaS expects you can read a stack trace. If you can’t, the category isn’t for you.

How ADaaS is different from what came before

The clearest way to understand a new category is by what it isn’t.

ADaaS vs Cursor / Copilot. Cursor and Copilot are human-in-the-loop tools. The human is at the keyboard; the AI augments the human. ADaaS removes the human from the inner loop. The human is at the meta-loop, defining tickets, reviewing outcomes, making judgment calls. The AI is doing the engineering.

ADaaS vs Devin / Cognition. Devin is the closest competitor in the category, and the comparison is fair. The differences are stack-specific (we tune for one stack and ship a polished cluster around it; Devin works across many) and posture-specific (we ship straight to production with no PR; Devin defaults to a human review gate). Both are valid. Both are autonomous development. ADaaS as a category covers both.

ADaaS vs Lovable / Bolt / v0. These are vibe-coding-as-a-service products, marketed at non-technical builders. They’re great for prototypes, demos, and weekend projects. They are not autonomous development. They run a model, they show the user the diff, they let the user accept or reject. The human is in the loop on every change. ADaaS removes that loop.

ADaaS vs OpenAI’s Codex / Anthropic’s Claude Code. These are the primitives on which ADaaS is built. They’re powerful interactive tools. Hunter writes most of his daily code in Claude Code, but they require a person at the keyboard to drive each session. ADaaS is what you build on top of these primitives to remove the person.

ADaaS vs your in-house engineering team. This is the comparison that matters most for buyers. An in-house team has organizational context an outside service can’t have. An ADaaS provider has accumulated infrastructure your in-house team would need to rebuild. The right answer for most companies in the next 36 months is both, your team focuses on architecture, judgment, and the parts of the codebase that need real human eyes; the ADaaS cluster handles the volume of routine tickets that would otherwise drown a small team.

“ADaaS removes the human from the inner loop. That’s the line that separates this category from everything else.” — Hunter Hodnett, Chipp CTPO

Why this is happening now

Three things had to be true at the same time for ADaaS to be a real category. They became simultaneously true in late 2025.

1. Models capable enough to ship code. Claude Opus 4 was the inflection point. Below that capability bar, you can’t trust the agent to write production code without supervision. Above it, you can. The bar moved up sharply with Opus 4 and has stayed up.

2. Tool surface rich enough to verify. The Model Context Protocol gave us a standard for browser control, log queries, database access, screenshot capture. Without verification, you can’t autonomy. With it, you can.

3. Context-engineering practice mature enough to scale. The discipline of what to put in front of the model so it doesn’t compact, hallucinate, or get lost didn’t exist as a named field two years ago. It exists now. (The full discipline →)

When all three are simultaneously true, autonomous development becomes possible. When it becomes possible at one company, the rest of the industry has 18 to 36 months before they have to either adopt or get outpaced. We’re in month four.

The buyer’s framework

If you’re considering ADaaS for your team, here’s the framework I’d run a provider through. Most don’t pass. The ones that do are the ones worth paying for.

Question 1: What does your verification loop look like?

If the answer is “we run tests after generation,” that’s vibe coding with a CI bolt-on. Pass.

If the answer is “we open a browser, navigate to the affected page, take a screenshot, and read the console logs,” that’s autonomous development. Continue.

The verification loop is the single highest-leverage component. Without it, the cluster is guessing.

Question 2: How do you handle context overflow?

If the answer is “we have a 1M token context, you’ll be fine,” they don’t understand the problem. Compaction will eat them.

If the answer is “we use a multi-stage pipeline, each stage gets a fresh context window, stages communicate via markdown files written to disk,” they get it.

Question 3: What’s your eject mechanism?

If the answer is “you log in to our platform and use our IDE,” you’re locked in.

If the answer is “your code is in your GitHub repo, our deployment workflow runs in your CI, you can stop paying us tomorrow and keep everything we built for you,” they pass.

This is the deal-breaker for me. ADaaS without an eject is just SaaS lock-in with extra steps.

Question 4: Where does the system get smarter?

If the answer is “as the model gets better,” the provider is a passthrough. Your investment in them doesn’t compound, you’re paying for someone else’s improvements.

If the answer is “the documentation our cluster writes for your codebase compounds; the scar-tissue rules in your CLAUDE.md accumulate; the outcome-labeled training data we archive becomes the basis for fine-tuning,” they’re building you a moat.

Question 5: Show me the failure modes

Any honest provider should be able to tell you exactly when their cluster fails and why. If they can’t, they haven’t run it long enough to know. If they can but won’t, they’re hiding something.

Our cluster fails on cross-tool integrations (third-party APIs the agent can’t directly observe), on decomposition of large features, on truly novel work that has no analog in our codebase. We say so out loud. We’d be suspicious of any provider that doesn’t.

Why we coined the term

You’ll notice we’ve been using “ADaaS” throughout this post like it’s an established category name. It isn’t. We started using it in early 2026. As of this writing, the search volume is low and the SERP is mostly dental-school applications.

We could have used “AI coding agent platform” or “autonomous coding service” or any of a dozen existing labels. We didn’t, because none of them name the thing we’re actually selling. The category needs a name. Categories that don’t have names don’t get bought.

So: ADaaS. Autonomous development as a service. Coined here, defined here, with the working understanding that the rest of the industry will catch up to it within 12 to 18 months because the underlying economic logic is too powerful to stay underground.

If we’re wrong about the category, the term dies. If we’re right, you’ll be hearing it a lot.

“Categories that don’t have names don’t get bought. We named ours.” — Hunter Hodnett, Chipp CTPO

Where Alchemist sits

Alchemist is our implementation of the category, the configured cluster, the verification loop, the documentation system, the eject mechanism, the maintained MCP fleet. The same system that runs Chipp’s autonomous engineering (the system I described in the manifesto) is what we’re packaging.

We expect competitors. We’re going to write about them when they ship; the category is bigger than any one company can capture, and the work of category-defining is mostly happens in public, in posts like this one.

What we’re going to differentiate on:

Stack opinionation. We picked one stack (Deno, Svelte, Cloudflare) and tuned the cluster against it. Generality is a tax. Specialization is a moat.
Eject by default. Your code is in your repo from day one. We win because you choose to stay, not because you can’t leave.
Bundle of practice, not just product. The cluster comes with the disciplines that make it work, CLAUDE.md patterns, sub-agent definitions, verification loops, doc system. You inherit two years of practice the moment you sign up.

The closed alpha is starting now.

The bottom line

Software development is the largest unproductized layer left in the software value chain. ADaaS is what productizes it. The pattern matches every prior -aaS revolution, the technology is suddenly capable, and the disciplines for using it are no longer secret.

The teams that adopt early will build software at engineering capacities a team an order of magnitude larger could not match. The teams that hold out will spend the next 24 months watching that gap widen.

If you’ve read this and you’re nodding, you’re our buyer.

Join the Alchemist waitlist →

If you want the long-form case for autonomous development, start with The Autonomous Development Manifesto.

If you want to see what an ADaaS implementation looks like under the hood, read Building a Self-Healing Bug Bot.