What these processes solve

The development method exists to stop drift, loss, and spaghetti.

This operating model combines the development method with a segmented DevOps coordination layer. The developer and local AI build the application inside the repo; Pubert creates the deployable operating context around that repo and can read it well enough to deploy, diagnose, and continue the work. The development method solves product-delivery drift through spec-driven, ratcheting, vertically sliced work verified three ways, while the broader process solves context loss, infrastructure improvisation, and delegation chaos around that work.

4failure classes handled directly: context loss, infra chaos, execution drift, product-delivery drift
2distinct operating roles: app-building in the repo, deployment and diagnosis around it
0need to restart from scratch every session when continuity is working
Pubert = continuity and coordination ratcheting = execution control continuity of context distributed infrastructure ratcheting protocol development method delegation without drift
Pubert's job

Maintain continuity of context, coordinate the operating environment, and preserve the decision trail so the repo can be deployed and diagnosed without reopening settled questions.

Simon and Simon2 split the load

The gateway handles public routing and entry points. The subconscious side carries the heavier storage, graph memory, ingestion, and processing concerns.

Ratcheting protocol

Turn decisions into forward-only execution: scope the slice, lock the plan, verify the work, and prevent the repo from slipping back into improvisation.

Developer and local AI

You and your local AI work inside the repo to build the application itself. That is a separate concern from the deploy-and-diagnose role Pubert handles around the repo.

The human remains in charge

The system lowers operational chaos; it does not replace the person who chooses direction, approves tradeoffs, and audits the outcome.

01

Problems the process and development method are designed to prevent

DEV

Product-delivery drift

Without a development method, teams drift into partial implementations, unverified features, and horizontal work that never becomes a shippable slice.

  • Spec-driven scope keeps each slice attached to a requirement.
  • Vertical slices keep progress end-to-end instead of fragmented by layer.
  • Three-way verification separates "it ran" from "it's right."
CTX

Context loss between sessions

Without a continuity layer, every session starts by re-reading logs, reconstructing who matters, and rediscovering open tasks.

  • Graph memory preserves entities, tasks, and relationships.
  • Log ingestion turns transcripts into structured history.
  • Agents resume from state instead of restarting from fragments.
INF

Infrastructure improvisation

When storage, routing, permissions, and serving assumptions are decided mid-flight, application work inherits hidden instability.

  • Simon and Simon2 separate gateway and heavy-processing concerns.
  • Prepared infrastructure removes repeated setup friction.
  • Nginx, storage, and serving paths stop being ad hoc decisions.
RAT

Execution drift and repo spaghetti

If repo-building and deploy-and-diagnose work are mixed together without a boundary, each actor can solve the same problem differently and leave the repo harder to reason about.

  • The ratcheting protocol locks each change into a forward-only slice.
  • ADRs and manager notes constrain execution before coding begins.
  • Delegation becomes narrow, surgical, and easier to audit.
02

How the process answers those problems

0. Scope the slice

Use the development method to pin work to a requirement and make the next change a ratcheted vertical slice.

1. Pubert: persist

Capture entities, tasks, and decisions so the system remembers more than the last conversation window.

2. Pubert: prepare

Coordinate routing, storage, permissions, and infrastructure so the repo the developer is building can be deployed and diagnosed cleanly.

3. Ratcheting: lock the slice

Use ADRs, manager notes, and explicit slice boundaries to close unresolved questions before delegation.

4. Ratcheting: verify and delegate

Let the developer and local AI build inside the repo, then verify the slice so Pubert can safely deploy, diagnose, and hand off the result.

Result: the developer and local AI build the app in the repo. Pubert handles the continuity, deployment, and diagnosis layer around that repo. The ratcheting protocol keeps the handoff between those concerns forward-only and auditable.