The Interface Is Free Now

Photo by Jan Antonin Kolar on Unsplash.

This week a project called ArtCraft put up a page with seven apps on it. PhotoCraft. VectorCraft. FilmCraft. LightCraft. PrintCraft. EffectCraft. DesignCraft.

You know what they are. Photoshop. Illustrator. Premiere. Lightroom. Acrobat. After Effects. InDesign.

Rebuilt from scratch. Written in Rust. Open source. Free.

Most of them are still in alpha or in development. That doesn't matter. What matters is that they exist at all.

DHH quoted it with a question: how many pencils, how many humans, how many hours would it have taken to recreate the Adobe suite by hand?

It's a good question. It's the wrong one.

The question that matters

The question that matters is simple: what is left to sell?

For thirty years, the interface was the moat. Learning curves were lock-in. Muscle memory was lock-in. Whole careers were built on knowing where a menu lived. Adobe could charge every month because leaving meant relearning everything.

That moat was expensive to build. Thousands of engineers. Decades of polish. Nobody could cross it.

Now somebody can. And if it can happen to Adobe — the most defended interface in software — it can happen to anyone.

Read the fine print

The part that caught my eye wasn't the screenshots. It was one word on the page: agent-ready.

Every app can be driven from a command line, a JSON control channel, or an MCP server.

Read that again. The people rebuilding the most famous user interfaces in history are designing them to be used without a user interface.

That's the tell. They know who the next user is. It isn't a designer clicking through menus. It's an agent calling a tool.

Where this goes

Follow the line forward and software collapses into something very plain:

A database. An API. An MCP server.

No SaaS dashboard. No proprietary desktop client. No settings page with forty-seven tabs.

The agent is the interface. It reads the data. It writes the data. It talks to you in your own words, and it draws whatever screen you need, when you need it — then throws it away.

Screens become disposable. Generated on demand, like a receipt.

If your product is mostly a beautiful skin on a database, the skin is now free. If your sales pitch is "our UI is easier," someone will generate an easier one this weekend. If your customers can export their data and point an agent at it, they don't need your screens anymore. They need your data, and a safe way in.

I don't say this to be dramatic. I build software for a living. This is my problem too.

But it's also the biggest opportunity I've seen in my career. When the interface is free, everything that is actually hard gets more valuable.

So what still costs money? Three things. Everything else is generated.

1. The data

Data is the one thing a model can't make up.

A model can generate plausible data all day. It cannot generate true data. Your customer list. Every job you ran. What you charged, what they paid, who called back angry, which house has a fifteen-year-old furnace. That is years of reality, written down one event at a time.

That gap — between plausible and true — is the whole game.

The deeper your data model, the stronger your position. A shallow app that stores a name and a phone number is a spreadsheet with a logo. A system that knows the home, the equipment, the history, the conversations and the money is something an agent can actually work with.

When the screens disappear, the database is what's left standing. Make it worth standing on.

2. The bridges

APIs used to be an afterthought. The "enterprise tier." The thing you built after the dashboard, if a big customer asked twice.

Flip it.

The API is the product. The MCP server is the product. The UI is the demo.

But a bridge is only as good as what an agent can do on it without breaking something. That means the boring things suddenly matter most:

• Scopes and permissions. What is this agent allowed to touch?
• Audit trails. Who changed this, and why?
• Safe writes. Can it retry without charging a customer twice?
• Clear contracts. Can a machine understand the tool without a human explaining it?

An agent on a bad API is an intern with a master key. An agent on a great one is the best employee you've ever had.

Five years from now nobody will brag about their dashboard. They'll brag about what their data plugs into, and how safely.

3. The rails

This is the part people miss.

Some edges of every business are regulated. Money. Messaging. Identity. Lending. Tax. To operate there you need approvals, legal entities, underwriting, audits and a track record. You need someone to say yes, and that someone is a bank, a card network, a carrier or a regulator.

I've lived this. Getting business text messaging registered with the carriers — brands, campaigns, consent language — is weeks of paperwork and rejections. Payment processing means underwriting, risk reviews, chargebacks and PCI. None of it is glamorous. All of it is real.

AI can write a beautiful app in an hour.

AI cannot get you approved by a card network. It cannot register your campaign with the carriers. It cannot become a licensed lender.

The regulated edges are the new moat. Whoever holds the rails holds the leverage, because every agent that wants to move money or send a message has to go through them.

The new stack

Put it together and it looks like this:

• Data at the bottom. True, deep, owned.
• Bridges in the middle. APIs and MCP servers, safe enough for agents.
• Rails at the edges. Payments, messaging, identity, compliance.
• Everything else on top — generated, on demand, disposable.

The companies that win will own data nobody else has, expose it cleanly, and hold the approvals AI can't fake.

The companies that lose will keep polishing screens nobody looks at.

Let me make it concrete with the industry I know best: home services.

Contractors don't want software

I've spent eight years building technology for home services. HVAC, plumbing, electrical, roofing. The people who keep your house warm, dry and powered.

Here's what I've learned: contractors don't want software.

They want the phone answered. They want the right truck in the right driveway. They want the invoice paid. Software was the tax they paid to get those outcomes.

And the tax keeps going up.

Look at the stack of a typical growing contractor. A field service platform. A CRM. A phone system. A texting tool. A review tool. A financing partner. A payment processor. A marketing agency's dashboard. Payroll. Accounting.

Each one is a login. Each one is a contract. Each one has its own copy of the same customer, spelled slightly differently.

The owner opens maybe two of them. The rest run quietly, charging monthly, while the office manager copies data from one screen to another.

That's not a technology problem. It's an interface problem. Every vendor built a screen, and the contractor became the integration layer.

The contractor's stack, after software

Here's what data, bridges and rails look like in a contractor's world.

One record of truth. Every customer, every home, every piece of equipment, every call, every job, every invoice. One place. Not ten copies.

Agents on top. They answer the call. Book the job. Dispatch the tech. Follow up on the estimate that went quiet. Collect the payment. Ask for the review. They work all night and never forget a callback.

Bridges out. To the field service platform the shop already runs. To accounting. To the supply house. Clean APIs and MCP servers, so the agent can read and write without anyone copying anything.

Rails at the edges. Card processing. Registered business texting. Consumer financing. Call recording consent. The regulated plumbing — pun intended — that lets money and messages move legally.

What the owner sees

Not a dashboard. A conversation.

"How many tune-ups did we sell last week?"

"Who still owes us money from September?"

"Text every customer who opted in and has a furnace older than fifteen years, before the first cold snap."

And it happens. Through the rails. Compliantly. With a record of who did what.

The contractor stops learning software. The software learns the contractor.

Advice for contractors

Own your data. Make sure you can export everything — customers, jobs, calls, invoices — whenever you want.

Ask every vendor three questions. Do you have an API? Do you have an MCP server? Who owns the data?

If the answers are vague, that's your answer.

Advice for builders

Stop competing on screens. The screen is free now.

Go deep on the data. Build bridges agents can trust. And do the hard, slow, regulated work of building the rails — because that's the part nobody can generate over a weekend.

Data + bridges + rails. Everything else is generated.

Build accordingly.

---

Edit, October 11, 2026: The ArtCraft team has gone after Microsoft Office now too. WordCraft, GridCraft and DeckCraft rebuild Word, Excel and PowerPoint. They're also written in Rust, open source and free, and they're also early alpha. Autodesk tools and other subscription software may be next.