Andrew G. Stanton - Thursday, March 12, 2026

A new phrase is entering the technology conversation: locally generated software.

Tools like Claude, Gemini, and local LLM environments can now generate entire applications on a developer’s machine. With a few prompts, a system can produce HTML, Python, Docker containers, and fully working services.

At first glance, this seems to represent a major shift toward sovereignty.

But there is an important distinction that must be understood:

Local generation is not the same thing as local sovereignty.

A program generated locally can still depend on remote infrastructure, remote identity systems, or remote data custody.

In other words, the code may originate on your machine, but the system may still rely on external control points.

True local-first architecture goes much further.

Local-first systems prioritize several principles:

1. Data Custody

Your data must exist primarily under your control.

Not in a SaaS database.
Not behind someone else’s API.
Not dependent on another company’s uptime.

When the system runs locally, your data should live with you.

2. Identity Custody

Identity is the root of sovereignty.

Many modern applications treat identity as something granted by a central authority:

• email providers
• OAuth providers
• platform login systems

But systems like Nostr invert that model.

Your identity originates with a key you control.

Applications can interact with that identity, but they do not own it.

3. Durable Archives

A locally generated application may still lose its entire history if a server disappears.

Local-first systems treat history as a first-class concept.

Your archive should be portable, reconstructable, and independent of any single service.

4. Network Optionality

Local-first systems assume the network may fail.

Connectivity becomes a feature, not a requirement.

You can still write, sign, and preserve work even when offline.

These principles matter because we are entering a world where software will increasingly be generated automatically.

If generation becomes trivial, the real question becomes:

Who controls the identity and the data behind the software?

Without sovereign custody, locally generated software may still be little more than a new interface for centralized systems.

But when local-first architecture is combined with sovereign identity, something different emerges.

The machine becomes more than a terminal.

It becomes a node of authorship and authority.

And that shift may ultimately prove more important than AI itself.

Work With Me

If you’re exploring:

• Nostr authentication
• Sovereign identity infrastructure
• AI-assisted workflows
• Local-first containerized systems

I offer a limited number of advisory and implementation sessions for builders, teams, and ministries working in these areas.

Typical engagements include:

• Architecture session (90 minutes) – $500
• Implementation sprint – starting at $2,500
• Ministry / Foundation advisory engagement – $2,500

Early Adopters

I’m also looking for early adopters interested in running Continuum, a local-first publishing and identity system built on Nostr.

There is no cost for early adopters, and I’m happy to personally help with installation and setup.

Even if you’re just curious and want to see how it works, feel free to reach out.

Feedback from early adopters directly influences the direction of the project.

Contact: andrewgstanton@gmail.com
or DM on Nostr:

@9wvc…guvd

You can also support this work as a Continuum Patron ($250).