Why Specularis exists

The paradigm shift

Software development is changing. Not just the tools we use, but how we think about building software itself.

For decades, we treated software like a blueprint: you design it, build it, and it's done. Specifications were static documents: write once, reference occasionally, update when something major changes, hand over to new teams. They lived in Word files, Google Docs, platforms like Notion or Jira and Markdown files in a repo. They were artifacts of a process, not living parts of the system.

But that model is breaking down: The pace of change has accelerated and with requirements evolving every day, the architecture needs to continuously adapt to new constraints. With code agents entering the picture as our true collaborators that build, refine and refactor systems alongside us, this pace will not slow down.

This isn't just about new technology - it is about a fundamental shift in how software is built.

No static specs

With code agents collaborating within development workflows, specs become living artifacts. They evolve with your code instead of separately from it. One agent might generate new specification based on your requirements and intent. Another one might then refine those based on recent code changes and a third one might then update it when you add a new feature.

This constant evolution of specs is actually a good thing, because it reflects your actual system, not an outdated snapshot from several months ago. But it creates the following new problem: How do you maintain a single source of truth when specs are constantly changing?

Traditional methods, tools and processes for documentation assume static content. They are optimized for humans writing documents rather than agents to evolve them. They are not made for the constant churn which we experience in agentic engineering. This leads to markdown files scattered across different project folders drifting out of sync or PDFs going stale missing a single place that stays canonical. As a result, you end up with multiple versions of the same spec without knowing exactly which one is authoritative.

The collaboration problem

This shift also is about how we collaborate. It's true that software development has always been collaborative, but now the nature of that collaboration is fundamentally changing.

We're moving from the model where humans write specs with agents executing them, to one where humans and agents are co-authoring systems. Rather than just implementing specs, agents suggest, refine and evolve which creates a new level of collaboration that our tools weren't originally designed for.

When one agent in your team updates a spec in a local specs folder, how is that change propagated to the rest of the team? Assume you refine a spec in the Specularis web app, how do other teammates and code agents know? When multiple agents work on different parts of the system concurrently, how do their changes stay in sync?

The answer isn't more complex tooling - it's simpler, more direct integration. Specs need to live in a place where both humans and agents can access them, update them, and stay in sync without complex workflows or manual processes.

The publishing problem

But collaboration isn't just about internal team members or agents. It's also about sharing your work with stakeholders, clients, and the broader community.

When specs are constantly evolving, how do you share them while keeping them canonical? Do you export a PDF that's already outdated? Do you send a link to a Markdown file that requires technical knowledge to read? Do you maintain a separate "published" version that drifts from your actual specs?

The answer should be simple: your specs should be shareable in their current state, without manual publishing steps, like Google Docs. PDFs should be generated from the latest version automatically. Sharing should be as easy as clicking a button and recipients shouldn't need to sign up or learn new tools, instead they should just see your work.

Specularis exists to fix this

Specularis is a workspace where specs stay canonical while constantly being evolved by humans and agents. It's built from the ground up for this new paradigm:

For agents, the workflow is simple and reliable. Agents integrate directly via API and sync Markdown into a canonical workspace, ensuring specifications stay consistent across the system. Instead of managing files across repositories, they just need to sync their changes. In case of conflicts, the web application allows humans to resolve them never allowing silent overwrites or hidden divergence.

For humans, the web application acts as the single source of truth. It's always clear, which version is current and every change is automatically versioned so you can see what changed, when it happened and whether it came from a human or an agent. Humans can not only preview and read specs but also create, edit and co-author - so they stay in control of the workflow and can govern the project.

For everyone involved, the result is a workflow where artifacts stay aligned with reality. PDFs are generated directly from the latest state so they're always up to date, sharing documents publicly requires no sign-ups, and publishing happens automatically if allowed. There's no manual export process and no drift between the working version and the published one.

The bigger picture

This isn't just about specs becoming the future core artifact in agentic engineering. It's about recognizing that software development is becoming more fluid, more collaborative, and more continuous. The old model of "design, build, ship" is giving way to "evolve, refine, adapt."

Specularis exists because we believe specs should evolve with your system, rather than lagging behind it. They should be living artifacts that both humans and agents can contribute to in multi-human-agent teams. It should be easy to share and publish them and they should maintain a single source of truth, even as everything around them changes.

If you're working with agents and your specs are drifting, Specularis is for you. If you're still writing static docs that never change, you probably don't need it. But if you're part of this shift, if you're building software in a more fluid, collaborative way, then Specularis is built for you.

The Vision

We're not trying to replace your workflow. We're trying to give specs a home that makes sense in the era of agentic engineering - where humans and agents collaborate and specs evolve continuously.

The future of software development isn't about more complex tools. It's about tools that adapt to how we actually work: fluidly, collaboratively, continuously. Specularis is my contribution to that future.

Cheers,
(nerd)Ben