Insights

A Software Development Process for the AI Era

Humans set direction, AI executes, the system controls, humans hold final accountability — a seven-stage process with quality gates and a cross-cutting security track.

OrbAIX Engineering Notes · 2026

Core spirit

Humans direct — AI executes — the system controls — humans hold final accountability.

Three guiding principles

Spec is the source of truth

If code diverges from spec, spec wins; if code is more correct, update the spec at once to prevent drift.

The bottleneck has moved

Generating code is nearly free; the real cost is verification and review. Optimize around the new bottleneck.

Everything leaves a trace

Every AI action is traceable — which prompt, which agent, who approved — mandatory in regulated domains.

The Process

Seven stages, one loop

From context preparation to production feedback — each stage has a Definition of Done and a control gate.

Prepare context & input-spec quality

New

“Garbage spec → garbage code.” Prepare business context, constraints, project conventions and input/output examples before AI generates anything.

DoneEnough minimal context for AI to grasp the domain, conventions and constraints.

GateInsufficient context → do not proceed to code generation.

Gather requirements & clarify the spec

Separate “understanding the client's business problem” from “writing the technical spec.” Don't turn raw requests into a spec without the analysis step in between.

DoneA business-problem statement separate from the technical spec; every requirement has acceptance criteria.

GateAmbiguous or conflicting requirements are clarified with the client first — never left for AI to guess.

Architecture, Human–AI boundaries & risk map

Define what AI may decide autonomously and what requires human approval. The output is a risk map that flags high-risk modules in advance.

DoneA Human–AI authority table plus a risk map by module/flow.

GateHigh-risk parts are flagged “human approval required” — AI never merges alone.

AI generates code — the micro spec → code → verify loop

AI implements from the spec and knows to ask back on ambiguity instead of guessing. The real loop happens inside this stage.

DoneWorking code with tests for that part; ambiguities asked, answered and recorded.

GateIf AI must guess a key business assumption → stop, ask a human, update the spec, then continue.

Multi-layer automated verification — make the spec verifiable

Don't stop at test + lint. Natural-language specs must evolve into verifiable forms: Given/When/Then, input→output examples, property/invariant tests.

DoneEvery acceptance criterion of the task has a matching test, all green.

GateCriteria not yet automatable are explicitly marked “needs manual check” — never silently skipped.

◆

Security & Compliance — an independent gate

Cross-cutting

Not folded into general review. Runs alongside stages 4–5, automated (SAST, secret scan, data-leak checks) plus human approval. AI is especially prone to leaking sensitive data, loosening authorization, or hard-coding secrets while still passing tests.

GateAny change touching auth / authorization / sensitive data → mandatory approval by an authorized person.

Human review guided by the risk map

Don't read every line — but don't “trust AI and skip” either. Prioritize by the risk map (stage 2) and keep diffs small enough to actually read the critical parts.

DoneAll high-risk parts on the map have been read and approved by a human.

GateDiffs too large for meaningful review are sent back to be split — no bulk approval.

Feedback & spec update — including production signals

Turn the process into a learning loop. The strongest learning comes from observing the live system (observability) → fed back into the spec and risk map.

DoneLessons are recorded and actually turned into updates to the spec / conventions / risk map.

GateSpec not updated after a major lesson → the loop is considered not yet closed.

Continuous loop

Stage 6 feeds back into stage 1 — the process never “closes,” it keeps learning.

In summary

Humans direct, AI executes

This framework keeps the spirit that humans hold final accountability, while fixing three common weaknesses: it makes spec-checking concrete, adds an independent security track, and places the learning loop at the right altitude — with explicit DoDs and gates so the process is executable, not just theory.

Build AI software with OrbAIX

Have a project or an idea? Talk to our team.