Code is no longer the bottleneck — the process around code is. When agents compress build time from weeks to hours, approvals, reviews, handoffs and policies designed for human speed turn that acceleration into a queue.
Artena delivers the AI-Native SDLC: six stages, one versioned artifact per stage in git, humans at the gates, policy enforced at the moment of agent action, and metrics from day one. The agent does everything up to the production gate — and nothing beyond it.
THE BOTTLENECK IS NOT CODE — FOUR HUMAN-SPEED CONSTRAINTS
01 · APPROVAL GATES
Committees, workshops and signatures are designed for human pace, not for a stream of agent changes.
Our answer: stage transitions by artifact acceptance — automatically, without “who is next” meetings.
02 · REVIEW AND SECURITY
Security teams are sized for human volumes of code; an accelerated flow they cannot check in time.
Our answer: layered agent review via REVIEW.md; humans only on regulated and critical code.
03 · ROLE HANDOFFS
Every stage waits while someone writes a document and retells context to the next executor.
Our answer: an artifact in git instead of a retelling — the next stage reads the file.
04 · MANAGEMENT AND POLICIES
Controls designed for human decisions become unenforceable at agent flow.
Our answer: policy as code — skills and hooks applied at the moment of agent action, not at review weeks later.
SIX STAGES, SIX ARTIFACTS, ONE LOOP
1 · PLAN — intent.md
The author describes the problem in their own words; it becomes a versioned, machine-readable intent.md in hours, not weeks. Git stores the author, the time and the decisions.
Gate: your product owner accepts or rejects; acceptance opens Stage 2.
Artena mechanism: intent templates and a versioned intent/ catalog from day one.
Leading metric: time from conversation to committed intent.md.
Lagging metric: share of intents that reach spec; edits after the first commit.
2 · DESIGN — spec.md, with your policies as skills
Requirements and design in one session, bounded by your encoded standards — security, compliance, architecture, UX — applied while the spec is written, not discovered at review weeks later. Contested points go to named policy owners.
Gate: product owner signs the spec; high risk is aligned with the tech lead.
Artena mechanism: organization skills in SkillForge, versioned in git with named owners.
Leading metric: time between intent and spec commits.
Lagging metric: requirement rework after build starts.
3 · BUILD — plan.md before code; knowledge as files
The agent produces an executable plan — files, order, tests, risks, proof — and touches nothing until an engineer accepts it. Team knowledge lives in CLAUDE.md; the working rule “the agent erred twice — the fix goes into CLAUDE.md” becomes a habit. Mandatory policy is enforced by hooks at the moment of action; parallel sessions and sub-agents multiply one engineer’s throughput.
Gate: engineer accepts plan.md.
Artena mechanism: Reckon plan mode and honest gates; SkillForge hooks as deterministic guardrails.
Leading metric: first-pass merge rate; time from plan to merged PR.
Lagging metric: rework cycles; diff-to-plan match.
4 · TEST — evals woven into implementation
Checks are part of the definition of done, not a gate after handoff. Every bug is reproduced as a failing test first; a hook blocks test edits while fixing. A regression suite of 20–50 real tasks per team runs in CI on every change to the agent’s configuration — model, prompt, skill or hook. Every production incident becomes a permanent eval.
Gate: “done” means the checks pass and their literal output is attached.
Artena mechanism: Reckon exit gates, mutation and parity probes, diverse test generation; evals as the regression suite for your agent configuration.
Leading metric: first-pass CI; eval pass-rate over time.
Lagging metric: review time per PR; change failure rate.
5 · DEPLOY — layered review, autonomy by environment
Multi-layer agent review via REVIEW.md; humans approve regulated and critical code only. Autonomy grows per environment: free in dev, pre-approved actions in preprod, production only by release authorization. Agent records become PRs through branch protection; rollback is one rehearsed command.
Gate: code owner approves the PR; release manager authorizes prod.
Artena mechanism: Reckon review and adversarial panels; AgentSpace trust levels and outbound-action guards; a risk matrix sets verification depth.
Leading metric: time to first review — minutes; share of pipeline failures resolved without a human.
Lagging metric: defects escaped to prod; DORA.
6 · MAINTAIN — control bands close the loop
One stable metric per service with control bands: log at 1 sigma, diagnose at 2 sigma, act at 3 sigma. Scheduled code scans and an on-call agent feed the same review gate. An incident becomes a new intent.md — the loop closes; every fix adds an eval for its incident class.
Gate: service owner or on-call triages the intent queue.
Artena mechanism: AgentSpace routines and on-call agents; Dream Team turns incidents into training scenarios.
Leading metric: time from band breach to intent.md in triage.
Lagging metric: share of findings that became merged fixes; repeat incidents of one class.
FOUR PRINCIPLES
1 · Humans above the cycle.
People accept intent, spec and plan; approve PRs and production. The agent does everything up to the production gate — and nothing beyond it.
2 · Policy at the moment of action.
Standards live in skills (recommended) and hooks (deterministic): the agent complies while writing, not at review weeks later. Mandatory policy equals skill plus hook.
3 · Artifacts in git, not retellings.
intent → spec → plan → tests → release → new intent. The next stage reads a committed file; the history is the audit trail.
4 · Measure from day one.
Baseline before the pilot; leading metrics from git and CI, lagging from incidents and DORA. The answer to “what does it cost and what does it give” exists from day one, without a separate accounting system.
“The traditional SDLC was built for efficiency in an era when writing code was the longest and most expensive stage. That is no longer true.” — the response is to rebuild the process, not just accelerate coding.
THE STACK THAT POWERS EACH STAGE
PLAN and DESIGN → SkillForge: intent/spec templates, organization skills (security, architecture, compliance, UX) with named owners and versions in git.
BUILD → Reckon: plan mode, honest gates, CLAUDE.md discipline; hooks enforce mandatory policy at the moment of action.
TEST → Reckon: exit gates, mutation and parity probes, diverse test generation; evals in CI as the regression suite for your agent configuration.
DEPLOY → Reckon review plus AgentSpace: layered REVIEW.md passes, trust levels per environment, outbound-action guards; humans on regulated and critical.
MAINTAIN → AgentSpace plus Dream Team: control bands, scheduled scans, on-call agents; incidents become intent.md and training scenarios — the loop closes.
HOW WE DELIVER IT — THREE PACKAGES
PACKAGE A — SDLC AUDIT AND BASELINE (2–4 WEEKS)
We map your current process onto the six stages and find where human-speed controls will queue agent output: approval committees, review capacity, role handoffs, policies. You get a baseline — DORA, PR cycle, rework — and a stage-by-stage target design.
Deliverable: baseline report and target SDLC design.
PACKAGE B — PILOT (ONE QUARTER, UP TO 10 TEAMS)
intent.md and spec.md templates in git; CLAUDE.md per team; your policies as skills and hooks; evals on 20–50 real tasks per team in CI; Reckon as the verification layer; humans at every gate.
Success criteria — speed: intent-to-spec in days, not weeks; time to first review in minutes. Quality: first-pass CI and first-pass merge rate rising. Stability: rework and change failure rate not rising while speed grows.
PACKAGE C — SCALE AND OPERATE
REVIEW.md multi-layer review; autonomy by environment; control bands and on-call agents; incident-to-intent loop; model rotation every 3–6 months with ablation sweeps. Your platform team receives templates, base agent images, an agent registry with metrics, and an effect-measurement methodology — streams assemble agents from templates instead of reinventing them.
START WITH ONE REPOSITORY
You do not need a platform to begin. One repository with CLAUDE.md, intent and spec templates, and read-only steps in your pipeline is enough to start; everything else accrues stage by stage.
Book an SDLC audit — we will map your six stages, measure the baseline, and show where acceleration currently turns into a queue.