Open Source Is Dead. Long Live Open Source.

I replaced one open source system in our stack with two others.

That sounds contradictory. It is the point.

We moved our docs off Docusaurus, then built our combined website and documentation experience with Astro and Pagefind. Coding agents changed the cost of connecting those parts, which changed what it made sense for me to own.

The story started with our website.

I had lost control of our website

Webflow had helped us get online. That mattered. But over time, changing the site became too technical for the people who needed to move quickly and too cumbersome for the technical work I wanted to do.

The problem was not page speed. It was change speed.

As a founder, I need to move from an idea to something real while the thought is still sharp. Our website is where positioning, product understanding, design, documentation, and customer questions meet. When changing it feels heavy, the company learns more slowly.

A website builder encourages you to think in pages. Our site was no longer a set of pages. It had shared design rules, structured content, forms, analytics, SEO metadata, redirects, security checks, and documentation. A change in one place could create work somewhere else.

I did not need another editing interface. I needed one mechanism for the entire website.

I turned the website into a repository

I stopped asking which website builder would give us more flexibility. Instead, I asked what would happen if the website worked like our software.

The source of truth would be a Git repository. Content would be structured files. Design would live in reusable components and styles. Every change would arrive as a pull request. Automated checks would validate the build, assets, typography, SEO, and security before a person approved the result.

Coding agents could work across the whole system. They could read the architecture, follow repository instructions, update content and implementation together, run the checks, and return a reviewable result.

I (e.g. Claude or Codex, I do not remember what I used at that point in time) chose Astro as the open source foundation. It is designed for content-driven websites, but it did not force our content, design, or deployment into someone else’s operating model.

I spent a couple of days planning the boundaries. What belongs in content? What belongs in components? Which values need one source of truth? What should fail the build? What can an agent change? What still requires a human decision?

I started the implementation with Claude Code. At that moment, on this task, it was moving more slowly than I needed. I switched to Codex and completed the rebuild in one day.

The model switch was tactical. The architecture was strategic. A faster agent could help because the repository gave it explicit rules and checks that could show when the work was incomplete.

The website became a system I could steer

After the migration, the pace changed immediately.

Pages, components, content, documentation, design, configuration, CI, and security now move through the same pull request workflow. On active days, that can mean 10 to 30 website PRs of all types.

More changes are not automatically better. What matters is that each change is visible, reviewable, and recorded. I can move quickly without turning the website into a collection of unexplained edits.

What changed was not how the site looked or how it performed in a synthetic speed test. It was how directly I could steer it. When I see something that should change, I can act on it.

Managing our website is now mostly talking to Claude and Codex. It is like building software, but a different kind of software: pages, content, docs, design, and everything around them.

Then I removed Docusaurus

Once the website was under control, documentation became the obvious next boundary.

We had built our docs with Docusaurus. At the time, it was the right decision. The initial setup took a couple of days, then we could focus on content.

As our needs grew, the separation became expensive. The docs had their own design constraints, structure, and look and feel. The hierarchy we wanted did not fit naturally with the experience we were building on the main site.

So I brought documentation into the same repository.

About three hours later, we had the first working docs infrastructure. It included examples, a table of contents, multiple navigation levels, and a UI driven by the content. Authors add a page and its metadata. The surrounding interface derives from that source.

Then came search. About two hours later, the docs had full-text search with Pagefind. The search index is generated from the built documentation, so it follows as pages are added or updated.

The result is live in Early’s documentation.

Open source is dead. Long live open source.

I did not remove Docusaurus because it had failed as open source or because it was a bad tool. I removed it because the complete system no longer matched the experience we wanted to create.

I also did not build a web framework or a search engine. Astro and Pagefind had already solved those problems.

What died for me was the assumption that choosing open source meant adopting someone else’s whole operating model. That bargain made sense when integration was expensive. Choose a capable framework, accept its opinions, and avoid building the connections yourself.

Coding agents changed that calculation. They made smaller open source building blocks much faster to understand, connect, test, and maintain. I could use Astro for the site, Pagefind for search, and our own repository rules for everything specific to Early.

The choice was not between buying everything and building everything. Open source gave us capable parts. Coding agents made those parts composable at a speed I had not experienced before. I owned the architecture, the constraints, and the final decisions.

The founder lesson

Webflow and Docusaurus were useful choices for us. They helped us move at an earlier stage. The mistake would have been treating those choices as permanent after the company’s needs changed.

Founders inherit friction from decisions that were once correct. Because it arrives one small task at a time, it rarely announces itself as a strategic problem. It just becomes the way work gets done.

The cost of our old website was not one difficult edit. It was the growing distance between an idea and our ability to express it.

Rebuilding the mechanism closed that distance. The unit of work is no longer an edit hidden inside a tool. It is an intention expressed as a pull request, complete with the content, implementation, and evidence needed to review it.

The lesson is not that every startup should build its own website stack. It is to notice when a tool that helped you move is now deciding how fast you are allowed to learn. At that point, ownership may be worth more than convenience.

Open source is dead, in the sense that I no longer need to accept an open source product as a complete operating system.

Long live open source, because its parts have never been more useful.

Content is the deeper challenge at the heart of all this. A perfect mechanism does not decide what a company should say or how to turn experience into something useful.

That is a different founder story, and the next one I need to write.