ECP AI Multi-Agent Squad — Documentation
v3.3 10 Agents • 38 Subagents • 138 Skills • 4 Phases • 12 HITLs ← Ecosystem 🇧🇷 PT

ECP AI Multi-Agent Squad

An AI agent squad for complete product development — from strategic context to production deploy — operated with Human in the Loop (HITL).

AI Multi-Agent 10 Agents 12 HITL Gates 4 Phases 38 Subagents 138 Skills Claude Code
10
Agents
38
Subagents
138
Skills
4
Phases
12
HITL Gates
3
Required Inputs

AI Multi-Agent Squad — The Concept

Philosophy
AI Multi-Agent Squad with Human in the Loop

The ECP AI Multi-Agent Squad is a complete product squad operated by AI agents, where each traditional product team role (PM, Designer, PO, Architect, Devs, QA, Ops) is performed by a specialized agent.

The human acts as strategic decision-maker at 12 checkpoints (HITL gates) throughout the cycle, approving, rejecting or redirecting agent work. No agent advances without human approval.

The squad receives 3 markdown files + 1 target repository and generates all product artifacts: OKRs, backlog, prototypes, code, tests, CI/CD, dashboard and documentation.

Principles

Delegation, not replacement

The orchestrator coordinates and delegates. Each agent executes its specialty. The human decides.

Full traceability

Every output is recorded in JSON. Every human decision is documented. Every feedback is carried forward.

Atomic and idempotent skills

Each skill executes a single task and can be re-executed without side effects.

How It Works

3 Specs
briefing + tech + design
Pre-Flight Check
validate-inputs.mjs
Orchestrator
coordinates phases
Phase 01
Strategy
HITL #1
Phase 02
Discovery
HITL #2-6
Phase 03
Delivery
HITL #7-10
Phase 04
Operations
HITL #11-12
Complete product + docs/ + dashboard

Orchestrator Flow

Step 0
Pre-Flight Check
Programmatic validation (validate-inputs.mjs) + behavioral validation of the 3 specs. If it fails, stops and reports.
Step 1
Read context.json
Identify current phase and agent, load previous outputs.
Step 2
Trigger Agent
Prepare input with full context + target repository path. Call agent via Task.
Step 3
Save Output
Write agent output to {REPO_DESTINO}/{phase}/.
Step 4
Present HITL
Present output to human at checkpoint. Await decision.
Step 5
Advance or Return
If approved, advance to next agent. If rejected, carry feedback and return to agent.

Required Inputs

The squad does not start without the 4 inputs below validated. The 3 markdown files must exist at the root of the target repository.

Input 1
product_briefing_spec.md

WHAT to build — functional scope, business rules, target audience and constraints.

Required sections:

  • Product
  • Problem
  • Target audience
  • Business context
  • Core features
  • Business rules
  • Constraints
Phases 01 and 02
Input 2
tech_spec.md

HOW to build — tech stack, architecture, patterns and inviolable rules.

Required sections:

  • Tech stack
  • Architecture
  • Inviolable code rules
  • Design patterns
  • Deploy and infrastructure
  • Tests
Phases 03 and 04
Input 3
design_spec.md

WITH WHAT LOOK — palette, typography, tokens, components and design guidelines.

Required sections:

  • Color palette
  • Typography
  • Spacing and grid
  • Components
  • Theme / Mode
  • Golden rule
Phases 02 and 03
Input 4
Target Repository

WHERE to write — absolute or relative path of the folder where all squad outputs will be written.

{REPO_DESTINO}/
├── product_briefing_spec.md
├── tech_spec.md
└── design_spec.md

Two-Layer Validation

Layer 1 — Programmatic
validate-inputs.mjs

Cross-platform Node.js script that checks file existence and presence of required sections.

node validate-inputs.mjs {REPO_DESTINO}
Layer 2 — Behavioral
Orchestrator Validation

The orchestrator reads the 3 files and verifies they have the required sections defined in shared/schemas/input-contracts.md.

Generates a JSON validation report.

Phase 01 — Strategic Context

Phase 01
Strategic Context
Define the Objective, Key Results and Macro Opportunities (Pains, Needs and Desires) that make up the top of Teresa Torres’ Opportunity Solution Tree (OST).
HITL #1 Product Manager

What this phase produces

What must NOT appear

HITL #1 — Questions for the Human

  1. Is the Objective inspiring and does it guide product decisions?
  2. Are the KRs measurable and achievable within the defined timeframe?
  3. Are the Macro Opportunities linked to the right KRs?
  4. Are they real opportunities (pains/needs/desires) or disguised solutions?
  5. Is the scope appropriate for a discovery cycle?

Input: product_briefing_spec.md  •  Output: {REPO}/01-strategic-context/

Phase 02 — Product Discovery

Phase 02
Product Discovery
Prioritize opportunities, generate solution hypotheses, validate with navigable prototypes, structure the backlog in SAFe and assess Cagan’s 4 risks before committing engineering.
HITL #2 HITL #3 HITL #4 HITL #5 HITL #6 PO + Designer

6-Step Sequence

StepAgentActionHITL
1. PrioritizationProduct OwnerReceives the OST from Phase 01 and prioritizes opportunities by KR impact#2
2. IdeationProduct DesignerGenerates solution hypotheses for prioritized opportunities#3
3. Low-Fi PrototypeProduct DesignerSingle HTML wireframe — mitigates Customer Value Risk#4
4. High-Fi PrototypeProduct DesignerComplete prototype with visual identity — mitigates Usability + Value Risk#5
5. StructuringProduct OwnerTransforms approved hypotheses into Epics, Features and Stories (SAFe)#6
6. 4 Risks AssessmentPM + Designer + POCollective assessment: Value (customer), Value (business), Usability, Feasibility

Cagan’s 4 Risks

Customer Value

Do users want this?

PM
Business Value

Does it move the KRs?

PM
Usability

Can users actually use it?

Designer
Technical Feasibility

Can we build it?

Architect

Inputs: product_briefing_spec.md + design_spec.md  •  Output: {REPO}/02-product-discovery/

Phase 03 — Product Delivery

Phase 03
Product Delivery
Architect, build and test the solution defined in Discovery, ensuring the implementation faithfully reflects what was approved in prototypes and backlog.
HITL #7 HITL #8 HITL #9 HITL #10 Architect + Back + AI Engineer + Front + QA

5-Step Sequence

StepAgentActionHITL
1. ArchitectureSoftware ArchitectBounded contexts, API contracts, DB schema, ADRs, repo scaffolding#7
2. Back EndBack End DeveloperEndpoints, persistence, services, authentication, tests#8
3. AI EngineerAI Engineer ∥ Front EndChatbots, autonomous agents, RAG pipelines, AI guardrails (Claude API)#8.5
3. Front EndFront End Developer ∥ AI EngineerComponents, pages, API and AI integration, fidelity to design_spec#9
4. QAQAShift-left, exploratory, automation, AI adversarial scenarios, quality gates#10

Inputs: tech_spec.md + design_spec.md + approved backlog  •  Output: {REPO}/03-product-delivery/

Phase 04 — Product Operations

Phase 04
Product Operations
Operate the application with CI/CD, GMUD, deploy, observability, SLOs, DORA metrics, operational dashboard, A/B testing and cycle feedback with real learnings.
HITL #11 HITL #12 Operations + PM

Sequence

StepAgentActionHITL
1. InfrastructureOperationsCI/CD pipeline, GMUD, installation guide, SLOs, DORA targets#11
2. Dashboard + DocsOperationsOperational dashboard (4 sections) + documentation site (all phases)#12

Feedback Loop — HITL #12 Decisions

ResultAction
Variation wins and moves KRsFull rollout. PM updates baseline. Next cycle.
No variation moves KRsReturn to Phase 02 — revisit opportunities and hypotheses.
KRs worsenReturn to Phase 01 — revise OKRs and OST.
Technical bugReturn to Phase 03 — fix and new A/B round.

Input: tech_spec.md  •  Output: {REPO}/04-product-operation/ + {REPO}/docs/

Orchestrator

Central Agent
Squad Orchestrator

The orchestrator never executes tasks directly. Its role is to coordinate, delegate, manage HITLs and ensure the flow across all 4 phases.

Responsibilities

  1. Receive the request and identify which phase the work is in
  2. Trigger the correct agent with full context
  3. Present outputs to the human at HITL checkpoints
  4. Carry human feedback to the correct agent
  5. Manage feedback loop when A/B indicates need
  6. Keep /shared/memory/context.json updated

Orchestrator Rules

Forbidden
  • Execute a skill directly
  • Advance without HITL approval
  • Assume — always carry full context
  • Start without the 4 validated inputs
Required
  • Include previously approved outputs in the next agent’s context
  • Document human feedback before returning to agent
  • On error, try 1x with additional context before escalating
  • Inform the agent of the {REPO_DESTINO} path
agents/orchestrator/CLAUDE.md

Squad Agents

10 specialized agents (1 orchestrator + 9 operational), each with subagents and atomic skills. Total: 38 subagent groups and 138 skills.

🎯
Orchestrator
Coordination, HITL gates, context transport and phase management
All Phases
No subagents — coordinates the 9 operational agents
🧑‍💼
Product Manager
Strategy, OKRs, OST, metrics and A/B
Phase 01 + Phase 04
Market Research
Product Vision
Product Strategy
Metrics
🎨
Product Designer
Research, ideation, low-fi and high-fi
Phase 02
Customer Research
UX
UI
📋
Product Owner
Prioritization, epics, features and stories
Phase 02
Epic
Feature
Story
🏛
Software Architect
DDD, contracts, ADRs and repo scaffolding
Phase 03
Domain Design
System Design
Evaluation
Enablement
🔧
Back End Developer
API, services, persistence and tests
Phase 03
API
Persistence
Quality
Living Docs
🤖
AI Engineer
Chatbots, autonomous agents, RAG and AI guardrails
Phase 03 (parallel with Front End)
Chatbot Builder
Agent Builder
RAG Pipeline
AI Guardrails
💻
Front End Developer
Components, pages, integration and performance
Phase 03
Implementation
Quality
Performance
Living Docs
🧪
QA
Shift-left, exploratory, automation and metrics
Phase 03
Shift-Left
Exploratory
Automation
Quality Intelligence
Operations
CI/CD, GMUD, infra, SRE, dashboard and A/B
Phase 04
Flow
Infrastructure
Reliability
DevSecOps
Dashboard
Change Manager

Subagents & Skills

Each agent has specialized subagents that execute atomic skills. Full catalog below.

Product Manager — Subagents & Skills

Market Research
competitor-analysis
customer-segmentation
market-sizing
trend-scanning
Product Vision
north-star-definer
opportunity-brief-writer
product-principles
vision-writer
Product Strategy
assumption-mapper
four-risks-assessor
okr-facilitator
outcome-roadmap
Metrics
ab-test-analyzer
experiment-designer
leading-lagging-indicators
report-generator

Product Designer — Subagents & Skills

Customer Research
assumption-tester
continuous-interview-partner
ethnographic-researcher
insight-synthesizer
UX
ideation-facilitator
low-fi-prototyper
high-fi-prototyper
solution-sketcher
information-architecture
interaction-design
usability-evaluator
accessibility-checker
UI
component-spec
design-tokens
responsive-guidelines
visual-consistency-checker

Product Owner — Subagents & Skills

Epic
opportunity-prioritizer
epic-writer
enabler-epic-writer
opportunity-brief-writer
Feature
feature-writer
enabler-feature-writer
Story
user-story-writer
acceptance-criteria-writer
story-splitter
functional-documentation-writer

Software Architect — Subagents & Skills

Domain Design
bounded-context-mapper
context-map-writer
aggregate-designer
class-model-designer
ubiquitous-language-builder
class-diagram-generator
System Design
adr-writer
api-contract-designer
data-modeling
evolutionary-architecture
repo-scaffolder
Evaluation
build-vs-buy
risk-assessment
technical-debt-tracker
tech-radar
Enablement
architecture-pairing
dependency-audit
pattern-advisor
scalability-analysis

Back End Developer — Subagents & Skills

API
api-builder
auth-implementer
contract-enforcer
error-handler
Persistence
schema-builder
migration-manager
repository-implementer
query-optimizer
Quality
unit-test-writer
integration-test-writer
api-test-writer
mock-builder
Living Docs
adr-logger
api-documenter
code-commenter
schema-documenter

AI Engineer — Subagents & Skills

Chatbot Builder
conversation-designer
claude-api-integrator
context-manager
prompt-engineer
Agent Builder
mcp-server-builder
tool-use-designer
agent-orchestrator
autonomous-workflow
RAG Pipeline
document-processor
embedding-pipeline
retrieval-optimizer
grounded-response
AI Guardrails
prompt-injection-shield
data-leakage-preventer
scope-enforcer
safety-tester

Front End Developer — Subagents & Skills

Implementation
component-builder
design-to-code
responsive-implementer
state-management
mobile-identity
Quality
unit-test-writer
integration-test-writer
e2e-script-writer
accessibility-implementer
Performance
bundle-optimizer
caching-strategist
core-web-vitals-monitor
rendering-strategist
Living Docs
adr-logger
code-commenter
component-documenter
readme-writer

QA — Subagents & Skills

Shift-Left
story-quality-reviewer
testability-advisor
three-amigos-facilitator
risk-identifier
Exploratory
charter-designer
session-based-tester
heuristic-tester
edge-case-finder
Automation
api-test-writer
e2e-script-writer
performance-tester
test-data-builder
Quality Intelligence
quality-metrics
bug-reporter
postmortem-writer
blameless-retrospective

Operations — Subagents & Skills

Flow
pipeline-builder
deployment-strategist
dora-metrics-tracker
feature-flags-manager
toil-reducer
docs-generator
installation-guide-writer
Infrastructure
iac-writer
environment-manager
capacity-planner
finops-optimizer
Reliability
slo-sla-designer
monitoring-setup
incident-commander
blameless-postmortem-writer
DevSecOps
vulnerability-scanner
secrets-manager
security-pipeline-integrator
compliance-as-code
Dashboard
product-metrics-designer
sre-metrics-designer
dashboard-builder
Change Manager
gmud-writer
risk-assessor
change-approver

HITL Gates — Human in the Loop

12 checkpoints where the human evaluates, approves, rejects or redirects agent work. No agent advances without explicit approval.

HITLPhasePost-AgentCore Question
#101Product ManagerOKRs correct? OST without solutions?
#202PO PrioritizationRight opportunities prioritized?
#302Designer IdeationHypotheses approved for prototyping?
#402Designer Low-FiConcept validated? Value risk mitigated?
#502Designer High-FiUsability validated? Visual identity correct?
#602PO + PM + Designer4 risks approved? Ready for Delivery?
#703Software ArchitectSolid architecture? Contracts ready?
#803Back End DeveloperAPIs correct? Persistence validated?
#8.503AI EngineerAI solutions integrated? Guardrails active against prompt injection and leakage?
#903Front End DeveloperFront integrated with backend and AI? Design faithful to design_spec?
#1003QAQuality approved? Ready to operate?
#1104OperationsEnvironment ready? Deploy authorized?
#1204A/B TestingWinning variation? What did we learn?

Possible decisions at each HITL

Approved

Advances to the next agent or phase.

Approved with caveats

Advances with documented restrictions.

Rejected

Returns to agent with detailed feedback.

Communication Contracts

All agents communicate via standardized JSON. The orchestrator carries context between agents.

Orchestrator → Agent
{
  "phase": "01-strategic-context",
  "agent": "product-manager",
  "mission": "mission description",
  "context": {},
  "inputs_from_previous": {},
  "hitl_feedback": "feedback (if return)"
}
Agent → Orchestrator
{
  "status": "success | error | partial",
  "phase": "current phase",
  "agent": "agent-name",
  "subagents_used": [],
  "skills_used": [],
  "deliverables": {},
  "open_questions": [],
  "next_hitl": 1
}
HITL Approval
{
  "hitl": 1,
  "decision": "approved | rejected",
  "feedback": "human comments",
  "next_agent": "next agent"
}
Standard Error
{
  "status": "error",
  "agent": "agent-name",
  "error_code": "INVALID_INPUT",
  "message": "description",
  "retry_suggested": true
}
shared/schemas/agent-contract.md shared/schemas/input-contracts.md

How to Run

Prerequisites

Step by Step

Step 1
Prepare the 3 specs in the target repository
Create product_briefing_spec.md, tech_spec.md and design_spec.md at the root of the target repository following the template in shared/schemas/input-contracts.md.
Step 2
Validate inputs
node validate-inputs.mjs /path/to/target-repo
If it returns exit code 1, fix the errors before proceeding.
Step 3
Open Claude Code in the squad directory
cd ecp-ai-multi-agent-squad
claude
Step 4
Start Phase 01
Type in Claude Code:
Start Phase 01 — Strategic Context.
Target repository: /path/to/target-repo
The orchestrator will run the pre-flight check, present the validation report and, if approved, trigger the Product Manager Agent.
Step 5
Evaluate each HITL
At each checkpoint, the orchestrator presents the agent’s output. You evaluate and respond:
  • approved — advance to the next agent
  • approved with caveats — advance with restrictions
  • rejected + feedback — return to agent with instructions
Step 6
Complete cycle
After HITL #12, the cycle is complete. The target repository will contain all artifacts from the 4 phases, the documentation site in docs/ and the operational dashboard.

Squad Folder Structure

ecp-ai-multi-agent-squad/
├── CLAUDE.md                       # Entry contract + global rules
├── validate-inputs.mjs             # Pre-flight check cross-platform (Node.js)
├── README.md
├── agents/
│   ├── orchestrator/               # Coordination and HITL
│   │   └── CLAUDE.md
│   ├── product-manager/            # Strategy and metrics
│   │   ├── CLAUDE.md
│   │   └── subagents/
│   │       ├── market-research/    (4 skills)  competitor-analysis, customer-segmentation, market-sizing, trend-scanning
│   │       ├── product-vision/     (4 skills)  vision-writer, north-star-definer, product-principles, opportunity-brief-writer
│   │       ├── product-strategy/   (4 skills)  okr-facilitator, four-risks-assessor, assumption-mapper, outcome-roadmap
│   │       └── metrics/            (4 skills)  experiment-designer, leading-lagging-indicators, ab-test-analyzer, report-generator
│   ├── product-designer/           # Research, ideation and prototypes
│   │   ├── CLAUDE.md
│   │   └── subagents/
│   │       ├── customer-research/  (4 skills)  continuous-interview-partner, ethnographic-researcher, assumption-tester, insight-synthesizer
│   │       ├── ux/                 (8 skills)  low-fi-prototyper, high-fi-prototyper, ideation-facilitator, solution-sketcher, information-architecture, interaction-design, accessibility-checker, usability-evaluator
│   │       └── ui/                 (4 skills)  component-spec, design-tokens, responsive-guidelines, visual-consistency-checker
│   ├── product-owner/              # Prioritization and structuring
│   │   ├── CLAUDE.md
│   │   └── subagents/
│   │       ├── epic/               (4 skills)  epic-writer, enabler-epic-writer, opportunity-brief-writer, opportunity-prioritizer
│   │       ├── feature/            (2 skills)  feature-writer, enabler-feature-writer
│   │       └── story/              (4 skills)  user-story-writer, acceptance-criteria-writer, story-splitter, functional-documentation-writer
│   ├── software-architect/         # Domain and architecture
│   │   ├── CLAUDE.md
│   │   └── subagents/
│   │       ├── domain-design/      (6 skills)  bounded-context-mapper, aggregate-designer, class-model-designer, ubiquitous-language-builder, context-map-writer, class-diagram-generator
│   │       ├── system-design/      (5 skills)  adr-writer, api-contract-designer, data-modeling, evolutionary-architecture, repo-scaffolder
│   │       ├── evaluation/         (4 skills)  build-vs-buy, risk-assessment, technical-debt-tracker, tech-radar
│   │       └── enablement/         (4 skills)  architecture-pairing, dependency-audit, pattern-advisor, scalability-analysis
│   ├── backend-developer/          # API and persistence
│   │   ├── CLAUDE.md
│   │   └── subagents/
│   │       ├── api/                (4 skills)  api-builder, auth-implementer, contract-enforcer, error-handler
│   │       ├── persistence/        (4 skills)  schema-builder, repository-implementer, migration-manager, query-optimizer
│   │       ├── quality/            (4 skills)  unit-test-writer, api-test-writer, integration-test-writer, mock-builder
│   │       └── living-docs/        (4 skills)  code-commenter, api-documenter, schema-documenter, adr-logger
│   ├── ai-engineer/                # Chatbots, AI agents, RAG and guardrails
│   │   ├── CLAUDE.md
│   │   └── subagents/
│   │       ├── chatbot-builder/    (4 skills)  conversation-designer, claude-api-integrator, context-manager, prompt-engineer
│   │       ├── agent-builder/      (4 skills)  mcp-server-builder, tool-use-designer, agent-orchestrator, autonomous-workflow
│   │       ├── rag-pipeline/       (4 skills)  document-processor, embedding-pipeline, retrieval-optimizer, grounded-response
│   │       └── ai-guardrails/      (4 skills)  prompt-injection-shield, data-leakage-preventer, scope-enforcer, safety-tester
│   ├── frontend-developer/         # Interface and integration
│   │   ├── CLAUDE.md
│   │   └── subagents/
│   │       ├── implementation/     (5 skills)  component-builder, design-to-code, responsive-implementer, state-management, mobile-identity
│   │       ├── quality/            (4 skills)  unit-test-writer, integration-test-writer, e2e-script-writer, accessibility-implementer
│   │       ├── performance/        (4 skills)  core-web-vitals-monitor, rendering-strategist, bundle-optimizer, caching-strategist
│   │       └── living-docs/        (4 skills)  code-commenter, component-documenter, adr-logger, readme-writer
│   ├── qa/                         # Quality and tests
│   │   ├── CLAUDE.md
│   │   └── subagents/
│   │       ├── shift-left/         (4 skills)  story-quality-reviewer, testability-advisor, risk-identifier, three-amigos-facilitator
│   │       ├── exploratory/        (4 skills)  charter-designer, session-based-tester, heuristic-tester, edge-case-finder
│   │       ├── automation/         (4 skills)  api-test-writer, e2e-script-writer, test-data-builder, performance-tester
│   │       └── quality-intelligence/ (4 skills)  bug-reporter, postmortem-writer, blameless-retrospective, quality-metrics
│   └── operations/                 # CI/CD, infra and A/B
│       ├── CLAUDE.md
│       └── subagents/
│           ├── flow/               (7 skills)  pipeline-builder, deployment-strategist, feature-flags-manager, dora-metrics-tracker, toil-reducer, docs-generator, installation-guide-writer
│           ├── infrastructure/     (4 skills)  iac-writer, capacity-planner, environment-manager, finops-optimizer
│           ├── reliability/        (4 skills)  monitoring-setup, slo-sla-designer, incident-commander, blameless-postmortem-writer
│           ├── devsecops/          (4 skills)  vulnerability-scanner, compliance-as-code, secrets-manager, security-pipeline-integrator
│           ├── dashboard/          (3 skills)  sre-metrics-designer, product-metrics-designer, dashboard-builder
│           └── change-manager/     (3 skills)  gmud-writer, risk-assessor, change-approver
├── phases/
│   ├── 01-strategic-context/       PHASE.md + README.md
│   ├── 02-product-discovery/       PHASE.md + README.md
│   ├── 03-product-delivery/        PHASE.md + README.md
│   └── 04-product-operation/       PHASE.md + README.md
└── shared/
    ├── identity/                   Template for design_spec.md
    ├── memory/                     context.json (session state)
    └── schemas/                    Communication and input contracts

Generated Outputs in Target Repository

{REPO_DESTINO}/
├── product_briefing_spec.md          [INPUT]
├── tech_spec.md                      [INPUT]
├── design_spec.md                    [INPUT]
│
├── 01-strategic-context/             OKRs, OST, vision, principles
│   ├── phase-01-output.json
│   └── hitl-1.json
│
├── 02-product-discovery/             Opportunities, backlog, prototypes
│   ├── prototype/
│   │   ├── low-fi.html               Navigable wireframe
│   │   └── high-fi.html              Complete prototype with visual identity
│   ├── epics/
│   ├── features/
│   ├── stories/
│   └── hitl-2..6.json
│
├── 03-product-delivery/              Architecture, ADRs, code, tests
│   └── hitl-7..10.json
│
├── 04-product-operation/             SLOs, A/B, DORA, CI/CD, GMUD
│   ├── ops-output.json
│   ├── dashboard-output.json
│   └── hitl-11..12.json
│
└── docs/                             Navigable documentation site
    ├── index.html
    ├── fase-01..04.html
    ├── assets/
    ├── gmud/
    ├── dashboard/
    └── INSTALACAO.md

Agent Bibliographic References

Product and Strategy
  • Teresa Torres — Opportunity Solution Tree, Continuous Discovery
  • Marty Cagan — 4 Product Risks, Empowered Teams
  • Bernard Marr — OKRs and KPIs
  • SAFe 6.0 — Epic > Feature > Story hierarchy
  • IDEO — Design Thinking
  • Don Norman — Usability
Engineering and Operations
  • Eric Evans — Domain-Driven Design
  • Martin Fowler — Evolutionary Architecture
  • Sam Newman — Building APIs
  • Kent Beck — TDD / BDD
  • Gene Kim — DevOps Handbook
  • Google — SRE Book
  • Nicole Forsgren — Accelerate / DORA
AI and LLMs
  • Anthropic — Claude API, Messages API, Tool Use, MCP
  • OWASP — LLM Top 10 (prompt injection, data leakage)
  • Lewis et al. — Retrieval-Augmented Generation (RAG)
  • Yao et al. — ReAct (Reasoning + Acting agents)
  • OpenAI / Anthropic — Best Practices for System Prompts

Changelog v3.3

Update from March 25, 2026 — new AI Engineer agent with 4 subagents and 16 skills for AI solutions integrated into the product.

Itemv3.2v3.3What changed
Agents910+AI Engineer (Phase 03, parallel with Front End)
Subagent groups3438+chatbot-builder, +agent-builder, +rag-pipeline, +ai-guardrails
Skills122138+16 AI skills (4 per subagent)
HITL Gates#1–#12#1–#12 + #8.5+HITL #8.5 post-AI Engineer (guardrails and AI integration)
Phase 034 sequential steps5 steps (AI Eng ∥ Front)AI Engineer and Front End run in parallel after Back End
QAFunctional tests+AI adversarial scenariosQA now includes prompt injection, leakage and scope tests

AI Engineer — Details

New Agent v3.3
AI Engineer

Designs, implements and protects AI solutions integrated into the product using the Anthropic Claude API as the primary backend.

Required Security Principles:

  • Input Sanitization — sanitize all input before sending to the LLM
  • System Prompt Protection — system prompts never exposed to the end user
  • Output Validation — validate LLM responses before returning
  • Scope Enforcement — reject questions outside the domain
  • PII Detection — block personal data leakage
  • Rate Limiting — limit requests per user/IP
  • Logging & Audit — log interactions for auditing (no PII)
  • Fallback Graceful — safe responses when the LLM fails

Integration with other agents:

  • Software Architect → API contracts for AI endpoints and ADRs
  • Backend Developer → HTTP routes that AI Engineer consumes/exposes
  • Frontend Developer → chat/conversation components with the AI API
  • QA → AI adversarial scenarios beyond functional tests
  • Operations → API costs, LLM latency and AI-specific SLOs
agents/ai-engineer/CLAUDE.md

Changelog v3.2 (Mar 17, 2026)

Itemv1.1v3.2What changed
Agents89Orchestrator included as official agent
Subagent groups30+34Exact count of all groups
Skills70+122Complete inventory of all skills
PO / Story3 skills4 skills+functional-documentation-writer
Architect / Domain Design4 skills6 skills+class-model-designer, +class-diagram-generator
Frontend / Implementation4 skills5 skills+mobile-identity
Folder treeSkill countsCounts + namesEach group now lists all skill names