ADT – Auto Dev Team
Overview
ADT (Auto Dev Team) is a software platform that will be deployed and sold as SaaS.
Its goal is to mimic a real software development team using a multi‑agent coordinated system, capable of taking a software request from idea → design → implementation → testing → deployment → delivery, with strong quality guarantees and traceability.
ADT itself must be built using the same process it enforces for customers.

Core Concept
ADT is based on multi‑agent coordination, where:

Each agent has a clear role, similar to a real software team.
Each agent is a specialist in its role.
Each agent has access to the tools it needs to perform its job.
Agents collaborate through a defined workflow, challenge each other’s outputs, and improve quality via internal review.


Software Development Workflow (Customer Projects)
ADT must strictly follow the steps below when developing software for a customer.
3.1 Requirement Understanding & Complexity Assessment

The system interacts with the customer via chat.
The customer may upload an initial, basic requirement.
ADT must:

Ask clarifying questions.
Refine requirements.
Identify expected results, user flows, frontend needs, constraints, and edge cases.


ADT must assess:

Complexity level (low / mid / high).
Estimated time.
Estimated cost per step.


Security-related questions must be raised early:

Sensitive data?
Encryption at rest?
Preferred algorithms?




3.2 Software Design
Software design is a mandatory acceptance gate.
Depending on complexity, ADT must generate:

Component architecture diagrams.
Class diagrams.
UML diagrams (when applicable).
Integration definitions with external systems.
Sequence diagrams for business logic (if required).

Design must include:

Required external documentation.
API contracts.
Authentication mechanisms.
Service accounts, API keys, and official references (requested from customer).

Architectural constraint:

The solution must be a modular monolith.
Each module must be deployable alone or together, depending on use case.


3.2.1 Environment Preparation

One agent prepares a dedicated repository for the project.
All agents work on the same shared workspace.
GitHub is used for repository management (initially a personal account).
Workspace must be shared to avoid repeated downloads and allow true collaboration.


3.3 UX / UI Flow Prototype

After design acceptance:

ADT generates a navigable, previewable UI facade.
This is not final implementation.


Customer feedback is collected and iterated.
Once accepted, development proceeds.


3.4 Development (Agentic TDD)

Development must strictly follow:

Accepted design (3.2).
Accepted UX flow (3.3).


Testing is defined first (Agentic TDD).
Acceptance criteria = outputs of 3.2 and 3.3.


3.5 Testing
Testing has two phases:


Unit Testing

Run all unit tests.
Publish report.
Development must reach 100% success.



System / Interaction Testing

Deploy application to Kubernetes.
Create a dedicated namespace for the project.
Execute interaction tests.
Upload reports and findings to the repository.




3.6 Deployment

Deployment uses:

Kubernetes
Kustomize
GitHub Actions


Deployment happens as part of testing (3.5.2).


3.7 Verification
Verification checks that:

All workflow steps ran successfully.
Acceptance criteria are met.
Tests were executed correctly.
Application is deployed in the correct namespace.

A verification checklist is generated and published to the repository.

3.8 Delivery
Delivery options:

Source code as ZIP (clean, documented).
Repository fork to customer account.
Packaged artifacts only (compiled images).


General Considerations
Security

Security is mandatory at every step.
Secrets must never be leaked.
Sensitive data must be encrypted at rest when applicable.
Customers may define:

Sensitive fields.
Preferred encryption algorithms.




Pricing & Cancellation

Customers may abort at any step.
Pricing depends on progress and complexity.

Example:

Cancel at 3.1 → minimal fee.
Cancel after 3.2 → complexity‑based fee.




(Numbers are illustrative; real pricing TBD.)


Platform Capabilities (ADT Itself)
ADT must provide:

A system to sell the platform.
Customer signup and authentication.
Multi‑tenant support.
Organization & user management.
Multiple concurrent project requests.
Dashboards showing:

Money spent.
Money saved.
Time saved.


Analytics and error transparency.
Ability to debug delivered repositories.
Debugging treated as a new requirement flow.


🚀 Local Development (VS Code + Python + ADK)

Purpose:
Enable ADT to run locally in Visual Studio Code using Google Agent Development Kit (ADK).
No cloud, no Kubernetes, no CI/CD at this stage.


Phase 0 – Local Bootstrap (Mandatory)
Before any customer workflow (3.1–3.8), ADT itself must support local execution.