Reference Implementations
See Start Here for the fastest download/apply path. Use Implementation Path for the full ordered sequence.
The AEEF Reference Implementations translate the framework's 16 production standards, five pillars, and maturity model into runnable code, CI/CD pipelines, and drop-in configuration files. Rather than asking teams to interpret standards documents and build tooling from scratch, we provide three implementation tiers that map directly to organizational maturity levels and adoption timelines.
Each tier is a superset of the previous one. Teams start at the tier that matches their current needs and migrate upward as their AI-assisted engineering practice matures.
Who This Section Is For
Use this section if you need:
- a repo to clone or download now
- an apply checklist for Tier 1, Tier 2, or Tier 3
- language-specific starter templates
- a CLI orchestration wrapper for role-based workflows
- config-only adoption for brownfield codebases
If you need the normative requirements first, go to Production Standards.
External Adaptation Program
For companies adopting external orchestration ecosystems while preserving AEEF governance controls, use:
- External Standards Adaptation Program
- MCP Adoption Guide
- A2A Progressive Adoption Guide
- Protocol Mapping: AEEF to MCP and A2A
- Starter Repo Blueprints
- Public Repo Migration Notes
Tier Comparison
| Tier | Name | Standards Enforced | Maturity Target | Time to Setup | Best For |
|---|---|---|---|---|---|
| 1 | Quick Start | PRD-STD-001, 002, 003, 004, 008 | Level 2 | 30 minutes | Individual developers, small teams |
| 2 | Transformation | PRD-STD-001 through 009 | Level 3-4 | 1-2 weeks | Teams adopting AEEF over 4-6 weeks |
| 3 | Production | PRD-STD-001 through 016 | Level 4-5 | 2-4 weeks | Enterprise and regulated deployments |
AEEF CLI Wrapper
The AEEF CLI is a bash wrapper around Claude Code that orchestrates the Agent SDLC as a live workflow. Instead of manually configuring agents, the CLI:
- Spawns Claude Code with role-specific personas (product, architect, developer, QC)
- Uses Git branches as the workflow backbone (
aeef/product→aeef/architect→aeef/dev→aeef/qc→main) - Creates PRs as handoff artifacts between agent roles
- Enforces contract compliance via Claude Code hooks (PreToolUse, PostToolUse, Stop)
- Provides built-in skills:
/aeef-handoff,/aeef-gate,/aeef-provenance
aeef --role=product # Create stories → PR to architect
aeef --role=architect # Design architecture → PR to dev
aeef --role=developer # Implement code → PR to QC
aeef --role=qc # Validate + test → PR to main
See the AEEF CLI Wrapper page for installation, usage, and architecture details.
Repository Links
The reference implementations are distributed across five repositories, each serving a distinct adoption pattern:
| Repository | Purpose | Link |
|---|---|---|
| aeef-cli | CLI wrapper orchestrating Claude Code with agent roles | github.com/AEEF-AI/aeef-cli |
| aeef-enterprise-role-pack | Optional enterprise role-pack extending aeef-cli toward the 11-agent model | github.com/AEEF-AI/aeef-enterprise-role-pack |
| aeef-quickstart | Tier 1 template repo (use as GitHub template) | github.com/AEEF-AI/aeef-quickstart |
| aeef-config-packs | Standalone configs for brownfield projects | github.com/AEEF-AI/aeef-config-packs |
| aeef-transform | Tier 2 with CI/CD, agent SDLC, and metrics | github.com/AEEF-AI/aeef-transform |
| aeef-production | Tier 3 full platform with monitoring and overlays | github.com/AEEF-AI/aeef-production |
Choose by Constraint (Fast Matrix)
| Constraint / Need | Best Starting Path | Why |
|---|---|---|
| New repo, need guardrails today | Tier 1 Quick Start Apply Path | Fastest greenfield setup with CI + AI configs |
| Existing repo, minimal disruption | Config Packs | Selective drop-in adoption without repo replacement |
| Small team wants role-based agent workflow | AEEF CLI Wrapper | Same repo, 4-role baseline, branch/PR orchestration |
| Multi-team rollout over months | Tier 2: Transformation Apply Path | Phased rollout with CI/CD + agent SDLC + metrics |
| Regulated / enterprise production controls | Tier 3: Production Apply Path | Monitoring, drift, overlays, incident automation, 11-agent controls |
| Need full 11-agent model definition first | Agent Orchestration Model | Canonical model map + path chooser |
Repository Relationship Map (Docs Hub vs Downloads)
This website repo (private docs hub)
├─ /reference-implementations/ -> navigation + apply paths + comparisons
│
├─ Links to public repos:
│ ├─ aeef-quickstart (Tier 1 template codebase)
│ ├─ aeef-config-packs (brownfield config-only assets)
│ ├─ aeef-cli (live role-based CLI orchestration wrapper)
│ ├─ aeef-transform (Tier 2 implementation)
│ ├─ aeef-production (Tier 3 implementation)
│ └─ aeef-enterprise-role-pack (optional 11-agent role-pack for aeef-cli)
│
└─ Canonical orchestration model docs live under:
/transformation/agent-sdlc-orchestration/
Ownership Model (Private Website, Public Downloads)
- This website source repository (
AEEF-AI/aeef) is private and maintained by the owner. - Reference implementation repositories are public (
aeef-cli,aeef-quickstart,aeef-config-packs,aeef-transform,aeef-production) so users can clone, download, and apply them immediately. - The website acts as the documentation and navigation hub, while the implementation code lives in the public repos linked above.
- For local development, you may optionally add the public repos as Git submodules into a separate private umbrella repo, but they should remain independent public repositories for end users.
Config Packs: The Drop-In Adoption Path
Not every team needs a full template repository. The Config Packs repo provides standalone configuration files that you copy into an existing project without changing your application code. Each pack maps to one or more AEEF standards and can be adopted independently:
- AI Tool Config --
.cursorrules,.github/copilot-instructions.md, and Claude/Windsurf rules that enforce PRD-STD-001 (Prompt Engineering) and PRD-STD-002 (Code Review). - CI/CD Pipelines -- GitHub Actions, GitLab CI, Azure DevOps, and Bitbucket Pipelines workflows enforcing PRD-STD-003 (Testing), PRD-STD-004 (Security Scanning), and PRD-STD-007 (Quality Gates).
- Linter Configs -- Language-specific linter configurations for TypeScript, Python, and Go that enforce PRD-STD-006 (Technical Debt) and PRD-STD-008 (Dependency Compliance).
- Security Policies -- Semgrep rule packs and SAST/SCA configurations enforcing PRD-STD-004.
- Schemas -- JSON schemas for KPI records, provenance logs, and agent contracts.
See the Standalone Config Packs page for adoption instructions.
Choose Your Path
Selecting the right tier depends on your starting point, team size, and regulatory requirements. Visit the Adoption Paths page for a decision tree that guides you to the right starting point, or use this quick guide:
- Starting fresh with a greenfield project? Use the Quick Start template repo.
- Adding AEEF to an existing codebase? Use the Config Packs.
- Rolling out across an organization over 4-6 weeks? Start with Transformation.
- Operating in a regulated or sovereign environment? Go directly to Production.
How Standards Map to Implementations
Every configuration file, CI workflow, and policy template in these repositories traces back to a specific AEEF production standard. The Standards Coverage Matrix provides a complete mapping of all 16 PRD-STDs to the files and configurations that enforce them across each tier.
Relationship to Other AEEF Sections
- Production Standards -- The normative requirements that these implementations enforce.
- Transformation Track -- The 4-6 week adoption program that Tier 2 operationalizes.
- Maturity Model -- The maturity levels that each tier targets.
- KPI Framework -- The metrics that Tier 2 and Tier 3 collect and report.
Next Steps
- Use Implementation Path for the canonical sequence.
- Use Start Here if you need fast route selection.
- Use tier-specific apply pages (Tier 1, Tier 2, Tier 3) to execute in your repo.
- Use Standards Coverage Matrix for control-evidence mapping.