Executive reading · ~60 seconds

A prompt starts work, but does not prove acceptance or operation. FORGE organizes the cycle SPEC → EXPLORE → PLAN → RED → IMPLEMENT → GREEN → SELF-VERIFY → PR; release, readback, observation, rollback, and learning close the operational truth.

Generating code is no longer the center of gravity of an AI-assisted software cycle. The challenge became to maintain intention, authorization, execution, verification and operation linked to the same framework while models and agents produce changes at greater speed.

An prompt can start work. It does not alone define what should be accepted, who can promote, which artifact arrived in the environment or whether the behavior remained healthy after deployment. A reliable AI-native SDLC needs to transform human intent into a reconstructable chain of decisions and evidence — and it needs to be able to refuse plausible delivery.

This article presents the technical loop adopted as a reference by FORGE:

SPEC → EXPLORE → PLAN → RED → IMPLEMENT → GREEN → SELF-VERIFY → PR
                                                               ↓
                  LEARN ← ROLLBACK/ADAPT ← OBSERVE ← RELEASE

The first arc produces a candidate change. The second tests the operational truth of this change. PR is the border between the two; It is not the end of the cycle.

Executive summary

  • SPEC before generation: intent, scope, out-of-scope, acceptance, risk and rollback need to be explicit before choosing the implementation.
  • Proportional risk: R0–R3 changes the depth of design, review, threat, and authority required; it is not used to artificially reduce a risk until gate disappears.
  • Independent evidence: the same agent can implement and self-verify, but the evidence that releases a relevant consequence must fail independently of generation.
  • PR is not an operation: merge, build, release, deploy, readback, observation and rollback have their own receipts and authorities.
  • States are not synonymous: IMPLEMENTED, VERIFIED, and OPERATING describe different proofs.
  • FORGE+ AI Works: FORGE organizes the control plan; AI Works brings the execution plan closer. The composition is valid only in the implemented and qualified scope — not as a universal promise.

1. SPEC: transform intention into refuseable contract

The first mistake of an agentic flow is to ask “implement this” and treat the model response as the specification. FORGE's lightweight feature-spec fixes at least:

FieldQuestion you need to answerFailure avoided
objective and whywhat human outcome do we want to produce?optimize activity without result
in-scopeWhat will this change do?border ambiguity
out-of-scopeWhat won't she do?silent scope expansion
acceptanceWhat observation can approve or reject?plausibility approval
tests/evalsWhat signs materialize the contract?“green” unrelated to intention
riskWhat consequence is there if we are wrong?gate same for different impacts
rollbackHow to contain and reverse without inventing the incident?irreversible change by default

A useful SPEC need not be long. It needs to be refutable. If there is no explicit rejection condition, there is a description — not a contract.

2. EXPLORE and PLAN: context before editing

Agents are especially good at producing a coherent response to the context they are given. If the context omits conventions, dependencies, owners, gates, or parallel work, coherence may be stuck in the wrong problem.

EXPLORE maps the actual codebase: local instructions, affected modules, dependencies, contracts, data flows, existing tests, blast radius, and in-flight work. The output is an impact map, not a change.

PLAN converts this map into sequence: which contracts change, where tests are born, how borders will be preserved, what rollback exists and which decision needs ADR. A plan does not authorize an effect; it makes the proposal reviewable before the increased cost.

This separation reduces a recurring behavior: the agent discovering the architecture while it is already modifying the repository and transforming each late discovery into a new scope expansion.

3. RED → IMPLEMENT → GREEN: the oracle comes before the generator

In step RED, the contract is given an executable form before implementation. It can be test, eval, policy-as-code, schema validation, adversarial case or smoke with a real environment. The essential thing is to prove that the absence of the desired behavior is detectable.

IMPLEMENT It is then a process guided by this oracle. The agent can write, execute, compare and iterate without asking the human to program line by line.

GREEN it only confirms that the declared checks passed in the environment and in the observed bytes. It does not automatically confirm that:

  • tests represent the entire intent;
  • the constructed artifact is the same one that will be promoted;
  • the production environment accepts the same assumptions;
  • the system remained healthy after the change;
  • the business outcome occurred.

O DORA 2025 describes AI as an amplifier of the strengths and weaknesses of the organizational system. The point is loop-friendly: more generation increases the value of rapid feedback, platform, documentation, stable prioritization, and small batches; does not replace these mechanisms.

4. SELF-VERIFY: verify without confusing author and auditor

Self-check is required: suite, types, lint, security, coverage, build, smoke and checks from SPEC must be run through DoD. But she should not be given independence that she does not possess.

There are three different questions:

  1. Did the agent review their own work? This reduces obvious errors.
  2. Was an independent mechanism able to reject an inappropriate version? This reduces correlated failures.
  3. Did a human authority release the consequence? This assigns responsibility.

Independence can come from a compiler, kernel, adversarial suite, policy engine, scanner, human reviewer, segregated environment or second system with a different failure mode. Changing just the prompt or the agent name does not guarantee independence.

The NIST SP 800-218A does not differentiate between human code and AI-generated code for vulnerability assessment purposes: both need to be assessed before use. The document covers model development and integration, and declares deployment/operation of AI systems outside its scope. This limit reinforces why the operational arc needs to continue past the development gate.

5. R0–R3: autonomy proportional to the consequence

The risk classification avoids two distortions: maximum bureaucracy for any change and maximum autonomy for any task.

ClassTypical cutoutMinimum evidence and authority
R0documentation, typo or mechanical changeintent, diff, verification and release identified
R1reversible local behaviorfeature-spec, contract tests, self-verify and rollback
R2Zone 1, external contract, agent, migration or cross-productExplicit design, testable rollback, and expert review
R3auth, tenant, billing, security, structural decision or destructive productionADR, threat model, independent verification and human decision

The risk belongs to the effect, not the size of the diff. A line that extends authority could be R3; one hundred lines of documentation can continue R0. Demoting the class to escape gate is a governance failure and should be verifiable as such.

6. The PR does not close the SDLC

A ready PR concentrates SPEC, diff and development evidence. After it there are still distinct borders:

  1. merge: integrates a change into a line of code;
  2. build: transforms pinned source into identifiable artifact;
  3. release: registers a version and its criteria;
  4. deploy: applies the artifact to an environment;
  5. readback: reads back what was applied and compares it with the intention;
  6. please note: measures behavior, failures, cost and quality within a stated window;
  7. rollback/adapt: contains the consequence or produces new change;
  8. learn: incorporates what the evidence has changed in SPEC, checks and policy.

Each boundary needs to carry provenance: artifact source SHA, artifact digest, environment identity, gate result, authority, timestamps, and evidence references. “Workflow green” does not prove that the expected artifact is operating; “pod Ready” does not prove the behavior; “no alert” does not prove that observability covered the relevant failure.

7. IMPLEMENTED, VERIFIED and OPERATING

Using a single “ready” label erases the type of evidence available.

StateWhat sustainsWhat doesn't support itself
IMPLEMENTEDcontract or code exists in an exact source cutcorrection, integration, deployment or actual use
VERIFIEDdefined checks passed on identified subject, version and environmentlongitudinal stability or operation in another product
OPERATINGreadback and telemetry confirm the real path in a declared window and denominatoruniversal effectiveness, future absence of failures or fleet adoption

An implementation may be green locally and not published. A deploy can exist and not have reliable readback. An operation can be observed in one product and not transfer maturity to another. Preserving the three states prevents intention from becoming a production narrative.

8. FORGE as control plan; AI Works as an Execution Plan

The intended composition is simple to explain and easy to exaggerate.

A FORGE organizes intent, risk, roles, gates, decisions, evidence, states, and authority. It is the control plan that responds: what can move forward, with what evidence and under what responsibility.

AI Works brings together tools, agents, environments, execution and artifacts. It is the execution plan designed to transform an admitted intention into observable work.

Together, they form the architecture for bridging the gap between intent and verifiable change. This is an architectural direction, not a universal operating certificate. The factual cut of 11/03/2026 preserves four limits:

  1. AI Works exposes 12 kinds public, but only five pass through the build pipeline and publish the compiled artifact (Agent, Function, Workflow, Widget and Surface). A pinned documentation separates catalogue, compilation and publication.
  2. Generic Git Code Ops remains specified, but without implementing waves of sdk.code, private tree, Git changeset and GitHub writing. O pinned backlog records this absence; you should not infer arbitrary branch, commit, push or PR.
  3. In the cut audited by the base research, the main CI was deactivated. In the current cutoff, the workflow exists: PRs receive proportional gates, push in main runs the lightweight path and the full suite runs nightly or by dispatch. This is CI automation, not proof of release, deploy or operation.
  4. The sandbox has cut-qualified contracts and implementations, but does not support a broad claim of authenticated operation for all paths. The FORGE 3.3 operational pilot in AI Works is designated but not yet started.

Therefore: the FORGE makes autonomy eligible; AI Works offers real surfaces to run it on. The word “operand” only applies after the path and product in question produce the corresponding evidence. [HARNESS31-C2]

9. Counterpoint: more AI does not imply shorter lead time

In a randomized experiment with 16 experienced developers, 246 tasks and repositories in which they had an average of five years of experience, the METER found 19% increase in time with tools beginning in 2025. The study itself limits generalization to other developers, tasks, and tools.

In February 2026, METR reported that its later experiment suffered from insufficient selection and measurement to reliably estimate the current effect; the raw data suggested possible speedup, but constituted weak evidence about the size of the gain. This methodological update is more useful than choosing just one number: capacity changes, usage behavior changes, and the measuring instrument also needs to evolve.

An AI-native SDLC should not promise universal speed. It must measure lead time, throughput, stability, rework, cost and quality in the system itself, preserving denominators and versions.

10. A minimum receipt per change

To rebuild the cycle, each relevant change should be able to respond:

intent:
  spec_id: FEAT-123
  risk: R2
  source_sha: <sha>
candidate:
  artifact_digest: sha256:<digest>
  environment: staging
verification:
  contract_checks: [unit, integration, policy, smoke]
  verifier_identity: <tool-and-version>
  result: approved | rejected | inconclusive
authority:
  approved_by: <human-or-policy-owner>
  approved_at: <timestamp>
operation:
  deployment_id: <id>
  readback_digest: sha256:<digest>
  observation_window: <start/end>
  rollback_ref: <runbook-or-artifact>

receipt does not need to contain secrets, private prompts or personal data. It needs to contain the necessary links to prove that intent, artifact, verification, authority, and observation speak of the same change.

Checklist for the next delivery

  • Does SPEC declare what is left out?
  • Does class R0–R3 represent the real consequence?
  • Does RED prove that an inappropriate version is rejected?
  • Does the relevant tester fail independently of the generator?
  • Is the approved digest the same as the promoted artifact?
  • Is human authority separate from production and verification?
  • Is there environment readback, not just pipeline log?
  • Are IMPLEMENTED, VERIFIED, and OPERATING labeled without scope transfer?
  • Was the rollback prepared before the incident?
  • Does observation generate versioned learning, and not just a note of success?

Conclusion

The sustainable gain of AI in development does not come from replacing a programmer with an prompt. It comes from redesigning the system so that agents advance autonomously within explicit boundaries, produce rebuttable evidence and return authority to those responsible for the consequences.

The loop SPEC → EXPLORE → PLAN → RED → IMPLEMENT → GREEN → SELF-VERIFY creates a candidate change. Release, readback, observation, rollback and learning transform this change into qualified operation. Between the two arcs there is a simple rule: no layer can assert more than the evidence of its own subject, version and window allows.

Do you want to apply the contract to a real product? Use the checklist above on the next feature and talk to Fernando Parreiras or with the Trustyu to design a pilot with scope, risk and evidence defined before automation.

Direct sources and context

  1. Trustyu ADR-0030 — Spec-Driven Autonomous Feature Development. Loop, classes R0–R3 and boundaries of autonomy in the documentary section.
  2. Trustyu FORGE 3.3 — gate lifecycle v1. gate states, evidence, human decision, and limits of inference.
  3. Trustyu Works — operational pilot FORGE 3.3. Scope approved and qualification still pending.
  4. Trustyu AI Works — assets catalog and publication. Twelve public types and five compiled/published types in the cut.
  5. Trustyu AI Works — SPEC 056 Git Code Ops and backlog. Decision, scope and unimplemented status.
  6. DORA — State of AI-assisted Software Development 2025. Organizational research on AI as an amplifier and system capabilities.
  7. NIST SP 800-218A. SSDF profile for development of models and software that integrates them, with deployment/operation outside the declared scope.
  8. METR — Early-2025 AI and experienced open-source developers. Experiment, result, population and limits.
  9. METR — 2026 experiment-design update. Change in design and limits of the posterior signal.
  10. Fernando Parreiras — PR #66, base research for the AGILIDADE × AI campaign. Personal canonical essay, brief and editorial dossier that gave rise to this distinguished technical companion.

Editorial and responsibility note

This text combines public normative documents, attributed empirical evidence, and the author's technical analysis. IMPLEMENTED, VERIFIED, and OPERATING are separate states; references to FORGE and AI Works describe identified cuts and limits, not a claim of universal SDLC in operation. DORA, NIST, METR, GitHub and other brands belong to their owners; there is no sponsorship or endorsement. Tech Human and Trustyu operate commercially in engineering, governance and digital products.

Research, structure and writing were assisted by AI. Fernando Parreiras authorized the agenda, factual self-review and publication on 11/03/2026; there was no additional independent human review.

Research cutoff: 11/03/2026. Editorial status: special technical article authorized for 11/10/2026 at 9am BRT.

Editorial and responsibility note

Research cutoff
Last review
Recorded corrections
No corrections recorded.

The cutoff above applies to the canonical claims. Additional sources and their access dates are identified in the article body.

This article combines cited sources, analysis, and the author's professional experience. Verifiable data and factual statements are linked to their respective sources. Interpretations, hypotheses, projections, recommendations, and opinions represent the author's professional point of view at the time of publication; they do not constitute proven facts, a promise of results, or legal, financial, or technical advice applicable to a specific case. Consult the original sources and qualified professionals before making decisions.

Claims and sources

HARNESS31-C2

A durable harness should maintain session history, orchestration policy and execution isolation as explicit boundaries, while adapters and plugins prevent model or channel choice from becoming the security boundary.

Limit: The sources show two implementations, not a neutral interoperability standard. Actual permissions must be independently enforced and tested outside model choices. This is a source-bound design input; it does not prove product adoption, operational maturity, independent attestation, search ranking, AI citation or outcome.