The SliceOps Manifesto
The open framework and audit plane for AI-first software engineering. Multi-agent teams ship auditable software, not vibe code.
The problem we are naming
The industry spent two years debating whether AI replaces developers. That is the wrong question. The right one is structural: what does software engineering look like when most of the typing is done by agents and most of the judgment is done by humans?
Sprints assume humans bound by standups and two-week commitments. Agents have no such bounds — one slice takes five million tokens and ten minutes, the next takes sixty million and a day. Time-boxing that velocity into rituals designed for office workers is, quietly, an anti-pattern.
Multi-agent parallelism breaks a second assumption: that one developer touches one branch at a time. Run a dozen agents against one repository and, without explicit dependencies and atomic decision counters, the parallelism that should compound becomes the parallelism that conflicts.
You have git history, and you have hope. That is not an audit trail.
The thesis
SliceOps is the open framework and audit plane for AI-first software engineering. It is not a code editor. It is not an autonomous agent. It is not a code-quality tool or a post-hoc compliance platform. It is the layer that sits above all of those.
If Cursor, Claude Code, Devin, and Copilot are the agent runtimes, SliceOps is what runs on top of them: the unit of atomicity, the dependency graph, the decision ledger, and the audit plane that makes the whole stack legible to a human reviewer, a regulatory auditor, or the next agent walking in fresh.
It is open by design. The framework lives in markdown, the tools live in Python and TypeScript, the rules live in CI. No vendor lock-in. Anyone can adopt it. Anyone can fork it.
Four cornerstones
Stage > Sprint
A Stage is a temporal view derived from the dependency graph of work that is ready to run now. It is not time-boxed and not committed to in a ceremony. When the longest slice in the Stage finishes, the Stage closes and the next opens. The difference between a calendar and a critical path.
The slice is atomic — one chat, one PR
A slice is the smallest unit of executable work: independent, testable, useful. One slice equals one chat equals one pull request. The audit trail is the chat, plus the diff, plus the merge approval. If it is not in the slice, it did not happen. Slices are sized in tokens, not story points — deterministic and cross-model.
Decisions are flat-numbered, immutable, machine-readable
Every architectural decision is a Decision Record with a flat counter that increments atomically across the whole repository. Each carries frontmatter that maps to a cognitive entity model agents can reason over, and CI rejects any PR that violates the schema. ADRs, with the discipline that survives multi-agent collisions.
Postmortems and insights are training data
Every incident becomes a postmortem; every recurring pattern becomes an insight record. When a new agent enters the repository, those artifacts stop it from repeating known mistakes. The memory is durable, inspectable, and shared across agents and humans — not locked inside a model.
The audit plane
This is where SliceOps differs most from everything else. SonarQube audits code. Runtime tools audit execution. Vanta and Drata audit the company, after the fact. Credo AI audits models. All necessary. None of them audit the plane above the code.
That plane is architectural decision integrity: was the slice consistent with the section's spec? Was the spec consistent with the plan? Were the decisions cited the ones that actually govern the change? Did a cross-slice contradiction arise that needs resolving?
It is the plane that decides whether software produced by agents at scale is a maintainable system or a debt bomb. It is the plane no one else is watching — and the one SliceOps puts in the developer's editor instead of a compliance dashboard.
Compliance-ready by construction
There is a phrase worth retiring — compliance theater — and one worth installing in its place: compliance-ready by construction.
When you adopt SliceOps, every architectural decision is a record that maps to an ISO 42001 control, a SOC 2 criterion, or an EU AI Act documentation requirement. You do not write these documents because an auditor is coming. You write them because they are the framework. When the auditor comes, you export the ledger and you are done.
EU AI Act Article 50 enters force on 2 August 2026. ISO 42001 is already a procurement gate. The compliance roadmap is not a separate workstream — it is what happens when you ship slices.
The proof
SliceOps was not designed in a whiteboard session. It was extracted from the production reality of building Datta — a cross-industry product for regulated markets — with a small team and a fleet of Claude Code agents, measured by execution time, not calendar time.
More than 800 Decision Records, flat-numbered and lifecycle-tracked. One block shipped in four calendar days across nine atomic slices, under its token forecast, with 41 architectural decisions captured. Up to thirteen agents running in parallel against one repository. A 2.5× efficiency multiplier, measured against equivalent API token consumption.
This is dogfooding. SliceOps is the system trusted enough to bet a regulated banking spinoff on.
What this means for you
If you are a founder shipping with a small team and AI tools
This is the missing piece between “Cursor wrote my CRUD” and “we have a system we can audit.” The credibility rests on the artifacts, not on credentials.
If you are a CTO in a regulated industry
This is what turns your AI investment from a liability into evidence — the trail the EU AI Act and ISO 42001 require, produced as a byproduct of shipping software.
If you are a tech lead orchestrating multiple agents
This is the discipline that turns N agents into N times the velocity instead of N times the conflicts. The DAG, the atomic counters, the slice atomicity. None of it optional. All of it compounding.
The invitation
Try the framework on a single slice in your next sprint. Declare a decision record for a call you would have made informally. Run a forecast at the start of your next block and a retrospective at the end. See what the artifacts feel like — and what your agents do with them when they read them.
Build with discipline. Audit your decisions. Treat your agents the way industrial engineers treat their machines: with telemetry, retrospect, and the assumption that what is not measured will eventually break.
Ship with agents. Audit by construction.