Skip to main content
RustGrid

THE ADD FRAMEWORK / 01

Scrum is dead.
Long live the spec.

A proposed operating model for software projects where agents do the building and humans govern intent, constraints, and exceptions.

THE PREMISE

A different workforce needs a different structure.

ADD preserves the purpose of coordination and quality, then expresses it through specifications and checks a machine can execute. Human collaboration still matters; delivery no longer has to wait for a sprint boundary.

Scrum artifactADD replacementPurpose
SprintContinuous flowWork advances when its gates pass.
BacklogSpec queueVersioned intent, constraints, and acceptance criteria.
Story pointsBudget & actual costTokens, compute, and human time.
Stand-upLive telemetryFailures and blocked tasks surface as exceptions.
Status columnGate stateEvidence from the pipeline determines progress.
Sprint boardExecution graphTasks, executors, dependencies, cost, and proof.

EIGHT PRINCIPLES

The rules of the system.

01

Constraints over conversations

If a rule matters, make it machine-checkable.

02

Specs are the product

Humans own specifications. Code is an output.

03

Tests before code

Acceptance criteria become tests before execution.

04

Minimum viable model

Use the cheapest tier that meets the quality bar.

05

Gates, not routine reviews

Humans govern policy and handle exceptions.

06

Secure by construction

Least privilege; no secrets in prompts.

07

Everything is traceable

Link changes to their spec, executor, and cost.

08

The loop tunes itself

Use failures to improve constraints and routing.

4 SPEC ARTIFACTS

Intent becomes executable.

01

Constraints

The stack, dependencies, budgets, and data rules agents must obey.

02

Architecture decisions

Versioned ADRs explain why the system is shaped the way it is.

03

Acceptance criteria

Given / When / Then. Every criterion maps to a test before execution.

04

Test & documentation rules

Required coverage, test types, API documentation, and changelog updates.

Readiness rule: every acceptance criterion maps to a test. Ambiguity returns to a human before execution.

6 QUALITY GATES

Proof, cheapest checks first.

01

Static

Formatting, lint, type checks, and constraint policies.

02

Security

Secret scanning, dependency audits, SAST, and prompt-injection checks.

03

Architecture

ADR compliance, module boundaries, and forbidden dependencies.

04

Tests

Acceptance tests and coverage thresholds.

05

Documentation

Required docs, API references, and changelog changes.

06

Runtime

Preview smoke tests, performance budgets, and rollout checks.

Agents open pull requests. They do not merge directly, modify pipelines, or receive secrets in prompts.

4 + 1 EXECUTION TIERS

Escalate intelligence.
Keep accountability.

TierExecutorTypical work
0No modelScaffolding, code generation, formatting
1Small modelBoilerplate, CRUD, docs
2Mid modelFeature logic, single-module refactors
3Frontier modelCross-module design, security code
Last stopHumanAmbiguous specs and exhausted escalations

Framework policy: retry once with the gate error, then move up a tier. Use passing history to improve routing.

MEASURE THE OUTCOME

Cost. Quality. Flow.

01

Cost per delivered spec

Tokens, compute, and human minutes required to ship.

02

First-pass gate rate

Tasks passing every gate without a retry, by tier.

03

Escalation rate

Tasks moving up a tier or reaching a human.

04

Spec-to-production lead time

Time from ready specification to production.

05

Spec rejection rate

Ambiguous specs returned before execution.

06

Change failure rate

Deployments requiring rollback or a hotfix.

7 REPLACEMENT CEREMONIES

Meet only where machines cannot decide.

Every ceremony starts with evidence produced by the platform and ends by changing an artifact. If no spec, constraint, test, ADR, routing rule, permission, or priority changes, the meeting was unnecessary.

Daily · 15 min

Escalation triage

Assign every failed task or ambiguous spec. Cancel when the inbox is empty.

Replaces the daily stand-up
Twice weekly · 45 min

Spec readiness review

Reject ambiguity before tokens are spent. Every criterion must map to a test.

Replaces refinement and planning
Weekly · 60 min

Failure review

Turn repeated gate failures into constraints, tests, templates, or ADR proposals.

Replaces the system part of retro
Weekly · 30 min

Routing and budget review

Compare cost, first-pass rate, and escalation patterns; update tiers and budgets.

Replaces velocity tracking
Biweekly · 45 min

Architecture council

Approve ADRs and the architecture tests that make each decision enforceable.

Replaces ad-hoc design review
Biweekly · 60 min

Outcome review

Compare shipped behavior with the need, then reprioritize the spec queue.

Replaces sprint review
Monthly · 45 min

Security and permissions review

Remove unused access, inspect anomalies, and tighten agent policy by default.

Adds the review most teams miss

4-STAGE ADOPTION PATH

Replace the operating model one proof at a time.

01

Gates first

Make the Definition of Done executable for human and agent work.

Exit: a broken team rule fails CI.
02

One spec stream

Choose a low-risk area and run approved specs through agent pull requests.

Exit: people review exceptions, not every change.
03

Routing and cost

Add execution tiers, budgets, the failure review, and an exception rotation.

Exit: cost per spec is visible and one failure is prevented permanently.
04

Switch the operating model

Move work to the spec queue and replace sprint ceremonies with ADD reviews.

Exit: gate evidence drives state and every task traces to a spec.

RISK IS MOVED, NOT REMOVED

The framework names its failure modes.

WEAK GATES

Green does not always mean right

Human-approved acceptance criteria and mutation testing protect against trivial tests.

SPEC DRIFT

The requirement can still be wrong

Outcome reviews tie delivered specs back to product behavior and stakeholder feedback.

PROMPT INJECTION

Inputs can be hostile

Sandboxing, least privilege, scoped credentials, and security checks limit the damage.

COST RUNAWAY

Retries can consume the budget

Per-task and per-spec budgets stop loops and surface anomalies for review.

CONSTRAINT SPRAWL

Rules need a reason

Every constraint links to its failure or ADR and is pruned when it no longer earns its cost.

HUMAN JUDGEMENT

People must stay close to the system

Exception rotation, ADR ownership, and deliberate pairing preserve technical knowledge.

ABOUT THE FRAMEWORK

A working thesis, made practical.

Based on Agent Driven Development: Managing a Team That Builds With AI, published 24 October 2026. RustGrid is the reference implementation proposed by the paper. The framework defines the operating model; the product and roadmap show which parts exist now and which complete the control plane next.

THE NEXT WAY TO BUILD

Give your agents a system to work in.

Start with RustGrid’s execution foundation. Build toward a delivery system governed by specs, gates, and clear ownership.