VC-AD

(Value-Continuous AI Development)

Implementations are disposable, but value is continuous. A "Boundary-Driven" development protocol for the AI era.

Overview

VC-AD (Value-Continuous AI Development) is a development protocol that allows humans to maintain control over the "core" of design and responsibility while enjoying the overwhelming implementation speed of AI.

While leaving implementation details to AI, humans focus on defining the following "Structure of Value (Skeleton)":

Decision: Why was it decided (Fixing intent)
Boundary: How far is freedom allowed (Defining safe zones)
Connection: How systems connect to each other (Managing crossings)
Closure: How to take responsibility upon failure (Safe shutdown)
Component: Where do these apply (Scope of application)

By structuring these, we realize development where "implementations are disposable by AI at high speed, but only valuable designs are continuous."

VC-AD Constitution

Value Continuity Design Basic Constitution The Constitution of VCDesign

Relationship with VCDesign

While VCDesign is the "design principle (philosophy/constitution) for sustaining value", VC-AD is the implementation-oriented methodology that concretizes it as an AI development process.

VCDesign: Where is value born and lost / Where is the boundary of judgment (Human/AI)
VC-AD: Even if AI generates implementation, how to preserve value and responsibility / How to manage it as a protocol

VC-AD plays the role of connecting VCDesign's philosophy to the field of AI implementation.

Why VC-AD?

"Issues with AI-Era Development" and "Basic Structure of VC-AD (11 Boundaries)" are explained in detail on the following page.

Why VC-AD? Development Challenges in the AI Era and the Reason for 11 Boundaries

Usage (Quickstart)

VC-AD is not a "design everything first" method.
We proceed while separating the freedom for AI to build implementation and the boundaries where humans hold responsibility.
Paste the following prompt to Generative AI for assistance.

Minimum Prompt (Template)

Please read the following VC-AD protocols (YAML):

- https://raw.githubusercontent.com/VCDesign-org/architecture-yaml-protocols/refs/heads/refactor/split-by-role/decisions/decisions.yaml
- https://raw.githubusercontent.com/VCDesign-org/architecture-yaml-protocols/refs/heads/refactor/split-by-role/boundaries/boundaries.yaml
- https://raw.githubusercontent.com/VCDesign-org/architecture-yaml-protocols/refs/heads/refactor/split-by-role/connections/connections.yaml
- https://raw.githubusercontent.com/VCDesign-org/architecture-yaml-protocols/refs/heads/refactor/split-by-role/closures/closures.yaml
- https://raw.githubusercontent.com/VCDesign-org/architecture-yaml-protocols/refs/heads/refactor/split-by-role/components/components.yaml

Target: <component_id> (e.g., comp-payment-01)
Implement the paths under this component.
You must follow the applied Boundaries / Connections / Closures.
In case of failure, close the responsibility according to the Closure definition.

* Pressing the button copies the entire prompt.

Step 0: Unbounded Generation (Let AI run wild first)

Purpose: Prioritize speed and build something that works as fast as possible
Let AI generate the minimal implementation running on-memory/dummy IO/local
Do not instruct fine details midway, pass the TODOs until completion together
Do not fix "Boundaries" at this stage (assume it's breakable)

Step 1: Define Boundary (Draw the line to protect)

Purpose: Protect irreversible areas such as persistent data and external integration
Find points where persistence/operation/responsibility occur
Define "Conditions that must not be broken (must/must-not)" as Boundary there
Ex: Do not output PII / Audit log required / Do not write directly to OT control system

Step 2: Define Connection (Decide routes to cross)

Purpose: Clarify connection points (crossing points) between components
Declare crossing points A->B (API/Event/Batch) as Connection
Write only the "flow" for Connection (do not write principles or accident handling)

Step 3: Implement Closure (End safely even if it fails)

Purpose: Safely stop the system without breaking the whole even if an abnormality occurs
Define how to end upon failure for each Connection as Closure
Retry/Timeout/Circuit Breaker/Idempotency/Compensation/Escalation to human
Goal is to create a state where "responsibility closes even if it fails"

Step 4: Apply Component (Decide where it runs)

Purpose: Determine the specific place (directory/service) where the implementation applies
Define which Boundary/Connection/Closure applies to which directory/service using Component
This determines the "executable context unit" passed to AI

Implementation via YAML Protocol

VC-AD is concretized as protocols like decisions.yaml, boundaries.yaml.

Example: boundaries.yaml (Snippet)

boundaries:
  # Do not log PII (Personally Identifiable Information) without masking
  - id: "b-logging-04"
    name: "pii-privacy-protection"
    description: "Do not log PII (Personally Identifiable Information) without masking"
    type: "invariant"
    derived_from_decisions: ["d-logging-04"]

These are published as "Reference Protocol Set" in the following repository.

architecture-yaml-protocols (GitHub) VC-AD Reference Implementation

Research

2026-01 Deep Research Academic consideration of Value Continuous Design (VCDesign) and Boundary Oriented Architecture (VC-AD/BOA) in the era of generative AI automated coding

Summary

VC-AD is a "development method where judgment and responsibility continue as value even if implementation keeps changing".
It is positioned as a practical protocol to connect VCDesign's philosophy and the AI development field.