I'm fully immersed in AI tooling, enablement, and agentic development. I've sat across from enough platform decks and multi-million dollar contracts to say this clearly: Claude already replaced what you're charging two million a year for. The vendors just haven't confessed to their customers yet.

Four or five people across different industries asked me some version of this question in the last few weeks. Different companies, different stacks, same underlying confusion. "We're being pitched this big AI platform. Do we actually need it?" The fact that the question is being asked independently, by people who don't know each other, tells you the answer is already obvious to everyone except the people selling the platforms. So I'm going to say the quiet part out loud.

Quick definition before the hate mail starts. By "platform" I do not mean targeted tools that earn their keep. Datadog, Stripe, Snowflake, Postgres. These solve specific problems no individual team should rebuild. I mean the opinionated meta-platforms. The hyperscaler agent foundries. The "standardized" enterprise AI stacks. The fleet-wide governance control planes with their own resource models, their own DSLs, and their own implementation guides that read like K8s rewritten by a procurement committee. The abstractions someone else decided you needed because they had a license to sell.

Those are the ones that died.

What platforms were actually selling

Enterprise software was always a hedge against the cost of building custom. The pitch was simple. Writing it yourself takes months, costs a team, and creates something only your engineers understand. Pay us instead, get something organized, get a dashboard, get support.

That was a reasonable trade. For a while.

The hidden cost was everything that came with it. Lock-in. Abstraction layers you didn't ask for. Governance frameworks designed for a procurement committee, not a builder. YAML schemas for problems you haven't encountered. Dashboards built for someone else's mental model. Administration overhead that pulls you out of the problem space and into the platform's problem space.

You were buying organized complexity. You just didn't always see it that way.

The assumption that broke

Custom was expensive. That was the foundational assumption the entire industry was built on.

It's gone.

I deploy dashboards in 20 minutes. I build agent infrastructure in an afternoon. I write audit tooling as a CLI I fully understand and own. The thing that used to take a team and a quarter now takes a conversation and a focused session. The economics are not comparable.

These platforms solved a real problem when we were writing YAML and Terraform by hand. That's not a thing anymore. It's solved. The reason to bow down to someone else's abstraction was that authoring infrastructure cost real time. It doesn't. The premise is dead, but the platforms built on top of it are still being sold like nothing changed.

When custom is cheap, the platform stops being the pragmatic choice. It becomes the expensive one. A deadweight around your neck you can't wait to be free from.

What the new stack looks like

It's embarrassingly small.

Sharp domain expertise. Claude. A tight Python codebase with a CLAUDE.md that carries your context, constraints, and conventions. Railway or equivalent so deploy trivia disappears. That's it.

No orchestration runtime to operate. No 15 resource kinds to learn. No vendor support contract for a system you don't fully understand. No ticket to a platform team when you need a new capability.

When something breaks, you can read it. When you need something new, you describe it and it gets built. Your mental bandwidth stays on the business logic, the domain knowledge, the actual signal. That's the leverage.

What the hyperscalers are selling right now

Kubernetes for agents. Governance layers for your fleet. Centralized policy enforcement for your tool calls. Dashboards that show you what your agents are doing.

Sophisticated framing for folder structure and a config file.

The teams reaching for this are pattern-matching on a familiar problem: we have a mess, we need structure, let's find the platform that organizes it. That instinct made sense in 2022. Today the more honest question is whether the mess exists because you're missing a platform or because you haven't given your development workflow the right layer of intelligence yet.

Most of the time it's the second one. And no platform fixes that.

But how do you maintain order?

Git. CLAUDE.md. Skills. Mutable context via MCPs. Subagents as needed. Off to the races.

That's the ops model. The whole thing fits in your head.

Your intent lives in CLAUDE.md, versioned, readable, diffable. Your reusable capabilities live in skills. Your live context flows through MCPs, mutable and composable without redeploying anything. Subagents spin up when the problem is big enough to parallelize and disappear when it isn't. Git holds the history. You already know how to operate distributed systems. This is no different.

There is no platform admin. No upgrade cycle to schedule. No vendor to call when the abstraction leaks. No endless yak shaving to get back to the thing you actually wanted to build.

The opinion that you need to bow down to a platform to maintain order was always someone else's opinion about your competence. You don't need their structure. You need good habits and the right tools. You already have both.

The counterargument they'll make

"But what about teams? Consistency at scale? Governance for regulated workloads?"

Fair questions. Here's how I answer them.

Team consistency lives in CLAUDE.md and shared skills, not in a YAML schema enforced by a Go runtime. Every engineer on your team works against the same documented context and conventions, with the same calibrated assistant executing against them. That's more adaptive and more maintainable than 15 resource kinds in a control plane none of them fully understand.

For regulated workloads, the governance primitives that matter (tool gating, approval records, audit trails) can be written in clean Python you fully understand and own. Not trivial work, but not magic either. The vendor abstraction isn't doing something you couldn't do. It's wrapping the same primitives in a contract and a license fee.

But how does this scale at enterprise level?

It already does. Just not the way they expected.

Enterprise scale in 2022 meant hiring 20 engineers, buying the platform to manage them, and buying another platform to manage that platform. Headcount was the scaling unit. Complexity was the proof of seriousness.

The scaling unit now is tokens. Cheaper than headcount by orders of magnitude. Available at 3am in Belgium without a standup or a Jira ticket.

A team of two or three Claude-native engineers today does what took a full delivery team and a six-figure SaaS contract in 2022. The leverage didn't shift slightly. It shifted by an order of magnitude. The enterprise that figures this out first isn't building a smaller team out of cost-cutting. They're building a sharper one out of capability.

The capacity that used to go into platform plumbing now goes into customer problems, domain depth, and the products you couldn't ship before because you were too busy maintaining the scaffolding.

What this means

The industry is going to keep selling 2022 solutions for a while. The platforms exist, the contracts are signed, the teams are hired to support them. That inertia is real.

But the builders who figure this out first have a significant edge. Smaller surface area, faster iteration, infrastructure that fits inside their heads, and operating costs that don't require a board conversation.

Custom is the new default. Claude is the reason why.

Stay in the business problem space. Let everything else be handled by tools that are better at it than you are. That's the architecture that wins right now.

Thought between meetings, waiting for food on the riverfront of the Dijle in Mechelen, Belgium.