GO TO A SECTION

↑ ↓ to navigate · Enter to openExplore all sections →
FDEInterviews logo
← The FDE reading room

The autonomous development lifecycle / October 2026

Autonomous ADLC
for FDEs

Take software from specification to an accepted release.

Turn a customer requirement into a PRD, a specification and acceptance tests. Guide agents through implementation, verify functional and non-functional requirements, and connect release evidence to operational feedback.

Every answer, concept and course, every paper breakdown, all published video lessons, hands-on FDE Lab missions, Premium PDF guides and companion files, the full practice-test bank and work-sample downloads. Referral Premium excludes guide PDFs and their companion files.

Study alongside free video lessons.

Premium guide PDFs and companion files require active paid Premium or approved complimentary access. Referral Premium includes the rest of the site, but excludes these downloads.

89 pages · 34 chapters · PDF + code + worksheets

Autonomous ADLC for FDEs cover: a petrol-green ceramic circuit passes through brass gates, with a vermilion keystone on ivory.

Build / verify / operate / improve

pages in a six-part journey
89
original vector diagrams
18
tests in the local companion
54
primary references
42

What is Autonomous ADLC?

A development lifecycle in which agents help turn agreed requirements into working, verified and operated software, with explicit limits on execution and release authority.

The guide follows the development of ordinary software as well as agent applications. It explains how PRDs, BDD scenarios, coding tasks, tests and release decisions fit together, with implementation lessons from published company engineering accounts.

Three complete pages, free to read

Inspect the method and the evidence.

Read the skill-validation framework, the recovery state machine and a measured improvement experiment. Each preview opens an actual PDF page at full size.

34 chapters / six parts

One learning journey, from contract to improvement.

Define the lifecycle

Follow a customer requirement through a PRD, executable specification, BDD examples, functional and non-functional checks, and delivery decisions.

  1. 01

    Define the autonomous lifecycle

    p. 6
  2. 02

    Start with the customer outcome

    p. 9
  3. 03

    Write a specification an agent can execute

    p. 12
  4. 04

    Design the control boundaries

    p. 18

Assemble the toolset

Choose current tooling, inspect repositories with code property graphs, package and test skills, discover capabilities, and isolate execution.

  1. 05

    Assemble the toolset by responsibility

    p. 22
  2. 06

    Treat a model change as a release

    p. 27
  3. 07

    Make the repository inspectable

    p. 29
  4. 08

    Package reusable work as skills

    p. 31
  5. 09

    Validate skills at four levels

    p. 33
  6. 10

    Discover capabilities without granting authority

    p. 35
  7. 11

    Design RPC endpoints around operations

    p. 37
  8. 12

    Isolate execution and bind identity

    p. 39

Build and verify

Create reviewable changes, recover uncertain effects, bind approval, protect tests and evals, and build a resettable agent gym.

  1. 13

    Take an issue to a reviewable change

    p. 41
  2. 14

    Resume work without repeating effects

    p. 43
  3. 15

    Bind approval to the action

    p. 45
  4. 16

    Build the deterministic verification layer

    p. 47
  5. 17

    Evaluate outcomes, paths and effects

    p. 49
  6. 18

    Build a resettable agent gym

    p. 51
  7. 19

    Verify browser, mobile and performance behavior

    p. 53
  8. 20

    Threat-model the development lifecycle

    p. 55

Operate and improve

Manage telemetry, memory, cost, canaries and SRE. Use hill climbing and recursive improvement with independent acceptance and clear ownership.

  1. 21

    Record decisions without collecting everything

    p. 57
  2. 22

    Manage context, memory and caches

    p. 59
  3. 23

    Budget the completed task

    p. 61
  4. 24

    Release a bundle with a working stop

    p. 63
  5. 25

    Introduce agentic SRE through investigation

    p. 65
  6. 26

    Improve a candidate with hill climbing

    p. 67
  7. 27

    Govern recursive self-improvement

    p. 69
  8. 28

    Assign owners and retain evidence

    p. 71

Run the reference build

Run the local Python toolset, break approval and recovery paths, inspect the gym, and validate a skill and its RPC access.

  1. 29

    Run the local reference toolset

    p. 73
  2. 30

    Break approval and recover an effect

    p. 76
  3. 31

    Inspect the gym and the search

    p. 78
  4. 32

    Validate a skill and review its RPC access

    p. 80

Review and hand over

Defend three design decisions, work through ten review prompts and deliver an operating system another engineer can understand.

  1. 33

    Work through three design reviews

    p. 82
  2. 34

    Build the capability in stages

    p. 84

Defend the decision when the easy answer fails.

Three fictional design reviews connect implementation choices to customer consequences. Ten review prompts help you explain the boundary, evidence and remaining uncertainty.

Protected verification

The coding score rises

An agent edits its own tests and reports more resolved tickets. Determine whether the software improved or the evidence weakened.

Durable recovery

The deployment reply vanishes

The provider may already have committed. Recover the original operation and prove that only one effect exists.

Controlled improvement

The optimizer wants more authority

Separate a useful candidate change from expanded permissions and a changed evaluator. Promote only the accepted bundle.

Included / executable companion

Change a condition. Explain the result.

Trace a worked PRD and specification into executable acceptance checks. Run a synthetic release, lose its response and reconcile one durable effect. Test a changed skill after approval, competing budget reservations, episode isolation and a bounded optimizer. The archive passed 54 tests and 10 deliberate mutation checks.

Python and SQLite are enough for the local track. The walkthrough explains commands, expected results, failure diagnosis and the additional work needed for authenticated services, live models and production deployment.

12 editable operating worksheets

  • Customer outcome and action authority
  • Release bundle and skill review
  • Capability contracts and evaluation plans
  • Recovery drills and budget reservations
  • Canary releases and improvement experiments
  • Incident response and customer handover

Teaching code and synthetic data. No hosted execution, production credentials or model account required for the local track.

Continue from a chapter into practice.

These paths connect the guide to focused concepts, questions and course labs. The same links are clickable inside the PDF.

A shared vocabulary for the build

Autonomous ADLC
A development lifecycle in which agents help turn agreed requirements into working, verified and operated software, with explicit limits on execution and release authority.
Skill validation
Separate checks for package structure, helper correctness, agent behavior and operational permissions.
Code property graph
A program representation connecting syntax, control flow and data flow for analysis.
Agent gym
A resettable environment in which an agent acts and an evaluator checks outcomes against independent evidence.
Controlled recursive improvement
An agent proposes changes to components used in future work while acceptance data, authority and promotion remain separately controlled.

Questions about the guide

What is the Autonomous Agent Development Lifecycle?

A development lifecycle in which agents help turn agreed requirements into working, verified and operated software, with explicit limits on execution and release authority. The main focus is agents developing software from specifications. The software can be an API, application, pipeline or agent. The guide also explains the additional evaluations needed when the product itself is an agent.

Does it explain PRDs, BDD and non-functional requirements?

Yes. A worked recovery change connects customer intent, a PRD, functional and non-functional requirements, BDD examples, an agent task plan and acceptance evidence. The companion maps requirements to executable Python tests and keeps production integration, performance and operating checks visibly pending. The Gherkin file is a reading example; the bundled runner uses unittest.

Does the guide cover skills and skill unit tests?

Yes. Dedicated chapters cover skill packaging, package digests, metadata validation, deterministic helper tests, trigger and negative-trigger trials, adversarial inputs and promotion. The companion includes a latency-review skill and tested numerical helper.

Are MCP, RPC endpoints and discovery included?

Yes. The guide distinguishes advertised capabilities from authorization, explains the July 2026 MCP revision and A2A context, and designs RPC contracts around stable operations. The local companion contains a deliberately limited JSON-RPC dispatcher; it is not an MCP server or a network authentication implementation. The linked Agentic Protocols guide provides a separate local MCP track.

What does code property graph mean here?

A code property graph combines program representations so an engineer can follow syntax, control flow and data flow. The guide explains a refund example, how to build a useful evidence packet and where static analysis has limitations.

How are evals, AgentGym and self-improvement connected?

A resettable environment supplies controlled tasks, an independent evaluator checks actual effects, and a bounded optimizer proposes candidates. The guide distinguishes the AgentGym research project from its own local teaching gym, then explains hill climbing, held-out acceptance and protected controls for recursive improvement.

What can I run without a model account?

The Python/SQLite companion runs locally without external packages, model keys or cloud credentials. Its exact extracted archive passed 54 tests and detected 10 deliberately broken controls. It demonstrates release approval, recovery after a lost response, concurrent budget reservations, skill validation, an evaluation gym and a bounded search. It includes 12 editable worksheets.

Does a passing companion prove production readiness?

The companion uses local identities, editable SQLite stores and synthetic fixtures. It does not authenticate production users, execute untrusted code in a sandbox, deploy to a cloud or benchmark a live model. The guide identifies the separate adapters, protected services and acceptance evidence needed for those uses.

How current is the tooling?

The edition was checked on 24 October 2026 against official company, standards and open-source project documentation. It distinguishes framework, harness and runtime responsibilities, product-specific availability, model migrations and the exceptions in Google's Gemini CLI to Antigravity CLI transition. Recheck the linked owner documentation before adoption.

Who should read it?

Forward deployed engineers and application engineers building customer agents or coding-agent workflows. Basic Python, Git and HTTP familiarity helps. The early chapters establish the vocabulary before implementation, operations and improvement.

Is the complete guide included in Premium?

The PDF and companion are included with active paid Premium or approved complimentary guide access. Three complete sample pages are public. Referral-only online Premium does not include guide downloads. A lawfully downloaded copy may be retained for study under the publication notice; premium files may not be redistributed.

How does it connect to the courses and practice material?

The learning paths and PDF link to Harness Engineering, Production AI Agents, Hard Deployments, concepts, questions, labs and work samples. Use a chapter for the lifecycle decision, then follow its linked lesson or exercise for implementation practice. Each resource keeps its displayed access level.

How was this edition produced?

AI tools assisted research, writing, code and the original Gemini cover illustration. Technical figures are authored vector diagrams. Scenarios and numerical fixtures are labeled as synthetic. Automated checks and assistant review do not imply independent human editorial approval; the edition is prepared for publisher review.

FDEInterviews / Autonomous ADLC for FDEs

Build the next release on evidence you can inspect.

The complete 89-page guide and companion are included with active paid Premium or approved complimentary guide access.

© 2026 FDEInterviews.com. AI-assisted educational material prepared for publisher review. Synthetic cases and calculations are labeled. Teaching code requires production adaptation. See the publication notice and Terms of Service for permitted use and liability terms. Send corrections through Contact.