I just want to push index.html and not think about it

You have a finished page. One index.html, a stylesheet, a couple of images beside it. You want it at an address you can send to someone.

That is the whole request, and it is not the one the tooling answers. Ask where to put a finished file and you get a workflow: a repository, a build command, an output directory, an environment, a pipeline. Every step is defensible. Together they answer a different question.

What people actually ask

If you came for the answer rather than the history: turning the file into a link takes one prompt, once an agent is connected to a host. With no agent, a file that carries its own styles and scripts gets a 24-hour link in Publish HTML.

Someone posted to Hacker News under the title Ask HN: Why is Deployment so Hard?

There are so many tools available to help make deploying code easier but it's still one of the most feared/hated parts of software development for most people I know.

The thread drew two points and one reply, "Maybe just do heroku then", and sank. That author is asking about deploying code: they mention Kubernetes and Terraform. It is a developer's question, not ours. What stands out is that even at home, among people who deploy for a living, it got a shrug.

The version that matters here turned up elsewhere. In a thread about agents buying domains and deploying on their own:

I am watching people who can't code build and deploy dashboards and sites with Claude Code (desktop app - they don't use the CLI), then go cap in hand to developer friends to get it hosted on a domain (rather than some Vercel or whatever URL).

Cap in hand. The site works. The last step needs an acquaintance. Someone else building tools for themselves described the same wall from inside:

I myself have been vibe coding so many tiny apps/scripts/cron jobs that resolve tiny inconveniences in my life and the biggest pain point for me right now is making these available to my multiple devices over the internet.

Building is not their bottleneck. They ship cron jobs and scripts without help. Getting the finished thing to a URL stops them.

Experience does not remove the wall. Someone running several static sites, reacting to a pricing change, put it plainly:

I find it surprisingly difficult to find a host for simple static sites.

That complaint is about billing, not pipelines: the thread was a per-request pricing page. The sentence after it has everyone else's shape:

But all the hosts are like, "No, we include geo-redundancy! We include AI cloud functions! Move your build system to us, and then we'll bill you for every minute of your build!"

Four people, nearly three years apart, different skill levels, one request. I have a finished thing, I want it reachable, do not make this a project.

What they get told instead

The results are competent and about something else. Step-by-step guides open with source control and a build stage. Best-practice articles cover staging environments, environment variables, rollback strategy, zero-downtime releases, CI runners. Threads become stack comparisons within a dozen replies.

None of it is wrong. All of it assumes the thing being deployed is an application under active development by a team: state to protect, secrets to inject, a release process worth defending.

An index.html with a stylesheet beside it has no state, no secrets and no release process. It inherits the apparatus anyway, because the apparatus is what "deployment" means now.

Deployment is priced for applications

The cost of deploying was set correctly for applications and never re-examined for documents.

That price was earned. Deploying a real application was dangerous, and the industry spent years building discipline to survive it: reproducible builds, versioned artifacts, staged rollouts, automated rollback. Nobody sensible wants to give that back.

What nobody did was check whether a page owed the same price. The default hardened around the harder case, the simpler case got filed underneath it, and the ratio stopped being noticed. A folder of browser files now travels the road built for a system with a database, because it is the only road.

The inheritance shows in the vocabulary. A finished page needs no build, and you will configure a build command. It has no environments, and you will pick one. It cannot break production, and you will be offered a preview deployment to protect against that.

Nobody argues for this. It is not a position anyone holds. It is a default nobody revisited.

Where the complexity is real

The argument above collapses if you stretch it.

If the project owns a database, user accounts, private API keys, server-side code or scheduled work, the machinery is not overhead. It is why the thing keeps working. Environments, secrets management and a rollback plan stand between a routine change and a bad weekend. A site holding other people's data deserves every stage of that pipeline.

The mistake is not that the discipline exists. It is that the discipline became the entry point, and the simpler case never got its own door.

The gap is no secret, and other people are filling it. The commenter with the cron jobs is building his own answer: a shared host for small self-built programs, aimed at this exact problem. He is not the only one. When several people independently build the same missing thing, the thing is missing.

The short version

For the mechanics of what counts as "the page", why the file is called index.html and what travels with it, there is a direct answer in how to host an HTML file. If you are hitting the wall one layer up, inside a Claude artifact, that case has its own page. And when the file is already committed somewhere, publishing from a repository skips Pages entirely.

The point here is narrower. A finished page should reach an address without becoming a project. Where that works, it works because the publishing step matches the object being published instead of inheriting from a harder one.

That is the loop Birta is built around. The agent that already holds your files publishes them to a live HTTPS address. Every published version is kept, so a bad change goes back. Updating later without redeploying the whole thing runs through the same connection. Your own domain points at it when you want your name in the bar. Static sites only: a project with a database or server-side code belongs somewhere built for it.

For the wider argument about that publishing layer, see vibe deployment. For the walls after the address, the domain, the form and the payments, see the deployment gap. And if there is no file to push yet, building a site without a builder starts at the empty page and ends at your own domain.

Push index.html, get an address, go back to what you were doing.