Intent to Evidence: Glossary

Agentic Development Life Cycle (ADLC) The software lifecycle when agents, not humans, produce most of the code. The category name. Others use it too, sometimes for a different thing (building agents as products). Here it always means one thing: how software gets built when the generator is a machine.

Intent to Evidence The model I use for the ADLC. Six phases arranged as a loop. Intent enters at one end. Evidence that the intent was met, and that nothing else happened along the way, comes out the other. Everything between is machinery. The name is also the test: if you cannot trace a line from what you asked for to proof that you got it, the lifecycle is broken somewhere in the middle.

The moved bottleneck The central claim. For forty years the constraint on software was producing it. When production became cheap, the constraint did not vanish. It moved to Intent, Validate, and Govern. Most organizations are still staffed, tooled, and measured for the old location.

Calibrations, not principles Most of what the classic SDLC treated as best practice was not a principle. It was a setting tuned to human throughput: review sizes, scan cadence, sprint-length test cycles, release gates. Calibrations do not fail loudly when the input changes. They just stop meaning anything.

The six phases

Intent The goal, constraints, and acceptance criteria for what is about to be built. What the system must do and what it must never do. In the ADLC this is the highest-leverage human work in the building, because it is the part a machine cannot supply and the part everything downstream is bounded by.

Generate Agents produce code, tests, documentation, and infrastructure. Parallel, fast, non-deterministic. The phase that used to carry all the weight and now carries the least.

Validate Determining whether what was generated is correct, secure, and what was asked for. Must be independent of the generator. If your validation depends on the thing it is checking, it is not validation.

Govern Policy, license, provenance, consent, and audit. In the ADLC this is a continuous phase, not a release gate. It runs upstream as constraints on generation and downstream as observation of what shipped.

Deploy Shipping to production. Mechanically the least changed phase. Operationally strained by volume nothing upstream was built for.

Observe What the system does once it runs. Runtime behavior, incidents, drift, usage. Fed back into Intent. The phase that turns a pipeline into a loop.

The ideas

Intent is the new source code When agents write the implementation, the specification becomes the artifact a human still authors and the artifact that bounds the result. Specs, constraints, and acceptance criteria stop being documents about the code and become the upstream form of it.

The independence thesis The generator cannot be its own auditor. A system that checks its own work will optimize for the check and find the shortest path to a passing score. Independence has to be structural: separate tooling, separate signals, in some cases separate people. Started as a security principle. In the ADLC it is an organizational design principle.

The shortest path to a passing score What a capable agent finds when the measure of success is a test it can see. Not malice. Loyalty to the wrong target. The reason validation must be independent.

Ambient governance Governance expressed as constraints before generation and enforced as observation after deployment, rather than inspected at a gate in between. The gate does not disappear. It stops being where the work happens.

Loop, not pipeline A lifecycle that returns production evidence to the next round of intent. Organizations still running ticket-to-release as a straight line discard the one signal that got cheaper along with the code.

Evidence Proof, independent of the generator, that the intent was met and nothing else happened. The output of the lifecycle. Not the same as green tests, and not the same as a scan with no findings. Those are inputs to evidence, not evidence.

The role

Full Stack PM The product role when the codebase is the single source of truth. The PM operates across the full stack of the lifecycle, from intent to observation, rather than handing a document to engineering and waiting. Three modes.

Codebase as single source of truth The premise of Full Stack PM. Not the ticket, not the PRD, not the roadmap. What is in the repository is what the product is, and product management moves to where the truth is.

Strategist mode The PM sets intent: bets, constraints, acceptance criteria, what not to build. The mode that feeds phase one. Missing it, agents build the wrong thing quickly.

Builder mode The PM ships directly: prototypes, specs as code, work in the repo. Missing it, the PM is either a bottleneck or a bystander.

Circuit Breaker mode The PM stops the line: kills a bet, rejects generated output, holds the quality bar against velocity. Missing it, speed outruns judgment and nobody notices until production does.

Operating terms

Escalation as designed An agent stopping and handing a decision to a human because the situation was outside its mandate. Counted as a failure by most dashboards. It is the system working. A validation and governance design that does not distinguish escalations from failures will optimize away the safest behavior it has.

Failure taxonomy Separating infrastructure failures, capability failures, and escalations as designed before quoting any agent success rate. A single blended number is not a metric. It is a rounding error with a decimal point.

Where the terms come from: the series Securing the Agentic Era on LinkedIn, and the director's cuts here on CorgiMind, starting with The Bottleneck Did Not Disappear. It Moved.. Corrections and arguments welcome.