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.
The autonomous development lifecycle / October 2026
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

Build / verify / operate / improve
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
Read the skill-validation framework, the recovery state machine and a measured improvement experiment. Each preview opens an actual PDF page at full size.

Page 33 / Sample
Separate package integrity, helper unit tests, model behavior and deployed permissions.
Open the page at full size ↗

Page 43 / Sample
Follow release state through dispatch, uncertainty and authoritative reconciliation.
Open the page at full size ↗

Page 67 / Sample
Read a measured local search and the diagnostic audit that exposes its limits.
Open the page at full size ↗
34 chapters / six parts
Follow a customer requirement through a PRD, executable specification, BDD examples, functional and non-functional checks, and delivery decisions.
Choose current tooling, inspect repositories with code property graphs, package and test skills, discover capabilities, and isolate execution.
Create reviewable changes, recover uncertain effects, bind approval, protect tests and evals, and build a resettable agent gym.
Manage telemetry, memory, cost, canaries and SRE. Use hill climbing and recursive improvement with independent acceptance and clear ownership.
Run the local Python toolset, break approval and recovery paths, inspect the gym, and validate a skill and its RPC access.
Defend three design decisions, work through ten review prompts and deliver an operating system another engineer can understand.
Three fictional design reviews connect implementation choices to customer consequences. Ten review prompts help you explain the boundary, evidence and remaining uncertainty.
Protected verification
An agent edits its own tests and reports more resolved tickets. Determine whether the software improved or the evidence weakened.
Durable recovery
The provider may already have committed. Recover the original operation and prove that only one effect exists.
Controlled improvement
Separate a useful candidate change from expanded permissions and a changed evaluator. Promote only the accepted bundle.
Included / executable companion
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.
Teaching code and synthetic data. No hosted execution, production credentials or model account required for the local track.
These paths connect the guide to focused concepts, questions and course labs. The same links are clickable inside the PDF.
Chapters 1–4
Chapters 5–12
Chapters 13–20
Chapters 21–28
Chapters 29–34
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.