Zero-Code Engineering: How a Custom Protocol Lets an AI Agent Write All Your Code

What Is Zero‑Code Engineering

A dev‑lifecycle skill is published that encodes the full development workflow—from requirement gathering, code writing, unit testing, code review, git merging, to Jenkins + Docker deployment—so that an AI Agent can execute every step.

The author spent a month without writing any business code; all work was performed by the Agent, while the human only produced spec documents, protocol specifications, and review comments.

Breakpoint‑Resumable Execution

To allow the Agent to continue after interruptions, the project’s development state is persisted in a JSON file. Before each session the Agent reads the phase field to decide the next action.

Example: when phase equals step:awaiting-review, the Agent asks whether to continue the review or approve it; when phase equals building, it queries Jenkins for the current build status.

Each completed action updates the phase and appends an entry to a task‑execution history, enabling a fresh session to restore the exact context. The state file is added to .gitignore so each developer maintains a private state machine.

Designing a Loop‑Feedback Engine

Development is inherently non‑linear, requiring repeated specification, coding, fixing, and recoding. The author therefore designs a "loop → feedback → loop" engine.

Review Loop : Every artifact (spec, code step) cycles through producing → awaiting‑review → revising → approved . The awaiting-review state persists, allowing the human to step away and later approve the item, after which the Agent proceeds.

Step Loop : Each business‑level step (e.g., vendor‑order encryption, integration testing) runs through developing → awaiting‑review → revising . The Agent advances step by step, waiting for human approval before moving on.

Auto‑Cascade Layers

Once a Review Loop reaches approved , subsequent actions cascade automatically:

Spec approval triggers automatic branch creation.

Code approval triggers automatic commit, push, and merge of the test branch.

Integration triggers CI build via Jenkins; successful builds lead to deployment notifications.

This three‑layer stacking turns a linear pipeline into a machine that can pause at any node and resume without further human input.

The Core: Operation Contract

All loops and cascades are driven by a formally defined Operation Contract that specifies, for each phase, the input, output, responsible actor, transition rule, and the fields written to the state file.

Examples:

Skeleton Ready : scaffold:done – driven by project‑init , automatically marks scaffold.ready=true.

Spec Intake : spec:intake → producing – Agent generates the spec and moves it to review.

Spec Review : spec:awaiting-review ⇄ revising – Human approves, writing reviews to the state file.

Branch Creation : spec:approved → branched – Automated git‑flow:init creates a feature branch.

Step Development : step:developing ⇄ awaiting-review ⇄ revising – Agent writes code; human approves each step.

All Steps Approved : code:approved – Automatic commit chain starts.

Push & Merge : pushed – git‑flow:commit / push runs automatically.

Integration : integrating → integrated – git‑flow:integrate merges; conflicts pause the workflow.

CI Build : building → deployed-test – Jenkins triggers; build status is recorded as build.status.

Completion : done – final state records the full history timeline.

Because every transition is codified, the Agent can resume from any phase simply by reading the state file, without needing to know the developer’s mental model.

AI Coding Paradigm Shift

The true transformation is moving from "vibe coding" to an AI‑Native workflow where the Agent is a first‑class citizen. The protocol abstracts actions into atomic, delegable steps, making the system independent of any specific Agent implementation.

This enables cross‑session, cross‑person, and cross‑Agent continuity, opening the possibility of a "One‑Person Company" where a single individual, equipped with an orchestrated skill chain, can deliver a complete software project that previously required an entire team.

In summary, a single orchestrated chain—from an empty folder to a deployed test environment—requires only human decisions at spec review and step review. The three‑layer loop‑feedback engine provides resumability and automatic cascading, while the operation contract guarantees predictability for every Agent action.