Files

T

Nova Slides Render / render (push) Failing after 1m4s

Details

docs(P1): strategic docs — thesis rename + NORTH_STAR objectives + RACI restructure

AUTONOMY_THESIS.md (git mv from NO_HUMANS_THESIS.md): reframe from
'removing humans' to 'autonomy in operations, human at stage gates'.
Drop D-### citations + internal file paths; keep anti-claims, reworded.
Anti-claim #1 now: 'decisions are NOT made by an LLM — deterministic
scripts calculate a score; the platform functions without AI'.

NORTH_STAR.md:
- Vision: 'invisible' → 'visible' (operations become visible — recurring
  theme); polish for technical audience (security, remediation velocity,
  reliability, lead time).
- Objective #2: 'provable trust in AI decisions' → 'provable trust in
  automated decisions' (deterministic scripts calculate a score;
  platform functions without AI).
- Objective #3: four CTO-grade metrics (Lead Time PR→Prod, Infra Vuln
  Count trend, MTTR, Cloud Spend Reduction) → all flow into PowerBI.
- Objective #4: 'default substrate for agentic consumption' → integrate
  with externally owned PDLC/SDLC/Agentic/Citizen Developer platforms
  regardless of source; Nova provides skills + MCP endpoints; all prod
  intents go through the same controls + quality gates.
- Anti-goals: drop #1 (hyperscaler competitor), #4 (legacy untagged),
  #5 (sold to operators). Add: 'not an upstream development platform',
  'not a replacement for the PDLC'. Reword #3 (no 'removes humans').

docs/raci.md: 3 roles → 4 roles. Add Quality Engineering column. Rename
Release Management → SRE. Split release attestation into Quality
attestation (QA) + Production readiness (SRE). Platform no longer holds
A for attestation — reassigned to QE/SRE.

docs/scope.md: add integration framing (skills + MCP endpoints, all
sources go through same controls).

Render scripts: default deck name → nova-autonomous-cloud-delivery.
ONBOARDING + terraform/onboarding: 'no-humans' → 'autonomous'.

---ci---
project: acdl
phase: 1
milestone: v1.21
status: execute
phase_role: execution
---/ci---

2026-08-11 13:55:53 +00:00

4.2 KiB

Raw Blame History

RACI — Who Owns What

This page is the citizen-developer-facing copy.

Nova's delivery lifecycle has four roles. This page clarifies who owns what — so the citizen developer knows what they bring, what the platform provides, what quality engineering guards, and what is co-owned with SRE.

The Four Roles

Citizen Developer (CD)

That's you — the consumer (technical developer L3A or non-technical L3B). You are Responsible for all Functional Requirements (FRs) and User Acceptance Testing (UAT). You produce the FRs + UAT via your AI coding agent, an upstream agentic SDLC platform, or any upstream development platform. The source does not matter — all are subject to the same compliance standards (the submission-readiness gate, the contract schema, the policy envelope, the immutable audit stream). Nova validates the submission, not the author.

Platform (Nova)

Nova is Responsible for all Non-Functional Requirements (NFRs), Infrastructure (cloud resource lifecycle, state, IAM), and Production deployments to cloud (the apply path, the pipeline, the release mechanics).

Quality Engineering (QE)

Quality Engineering is Responsible for the platform-side quality checks: policy enforcement, confidence scoring, schema validation, and the functional/contract/non-functional evidence that feeds attestation. QE owns the quality of what the platform produces — the gate evidence, not the gate decision.

SRE — co-owned with you

Production readiness is co-owned. SRE owns operational readiness: the operational attestation (incident response, capacity, resilience, DR). The platform performs the QA + SRE attestations agentically (it runs the confidence signal, the policy checks, the separation-of-duties). The citizen developer oversees and triggers the actual release — the human attestation at the stage gate is your authorization. The platform runs the checks; you authorize the promotion. This is the "autonomy in operations, human at stage gates" model.

The Matrix

Work Category	Citizen Developer	Platform	Quality Engineering	SRE
Functional Requirements (FRs)	R/A	C	I	I
User Acceptance Testing (UAT)	R/A	C	I	I
Non-Functional Requirements (NFRs)	I	R/A	C	C
Infrastructure (cloud, state, IAM)	I	R/A	I	C
QA (policy, confidence, schema checks)	C	R	R/A	I
Production deployment to cloud	I	R/A	C	C
Quality attestation (QA sign-off)	A	R	R	I
Production readiness (SRE sign-off)	A	R	C	R

Key: R = Responsible (does the work) · A = Accountable (owns the outcome, sign-off) · C = Consulted · I = Informed.

What This Means in Practice

You (Citizen Developer) bring:

Your application code + a contract that declares intent.
Your FRs (what the application does).
Your UAT (you accept the deployment when it meets your FRs).

Nova (Platform) provides:

The NFRs (security, observability, compliance — baked into the pipeline, not your concern).
The infrastructure (cloud resources, state management, IAM scoping).
The production deployment (the apply path, the pipeline, the release).

Quality Engineering guards:

The policy enforcement, confidence scoring, schema validation.
The quality attestation evidence that feeds the stage gates.

You co-own production readiness with SRE:

Nova + SRE run the attestations (QA quality sign-off, SRE operational readiness).
You authorize the promotion at the stage gate. No promotion happens without your recorded attestation.

Compliance Standards Apply Equally

Your FRs + UAT may come from any source — an AI coding agent, an agentic SDLC platform, or a traditional IDE. Nova does not differentiate. All submissions pass through the same gate (schemas/submission-readiness.schema.json): tags, environment metadata, policy preconditions, profile markers. The compliance standards are the same regardless of how the code was authored. This is by design: the audit trail is the same, the policy envelope is the same, the evidence stream is the same. The source does not matter; the submission does.

4.2 KiB Raw Blame History