Your repos. One coordinated delivery.

One request.
An AI team
across your repos.

Connect your requirements, backend, and frontend repositories. Describe a feature in Codex. codex-sdlc coordinates the AI roles, checks their handoffs, and brings the delivery back for your review.

Install for Codex Watch the introduction

Map your repositories once. Start each feature with an outcome.

Open source · Apache 2.0 · Guide: 0.5.0

YOU / THE REQUEST

“Let signed-in users save favorite items and find them later.”

AI · PMOne plan. Checked handoffs.

REPO 01 · COORDINATORRequirements/work/requirementsAI · BA

Requirements &
shared run record

REPO 02Backend/work/apiAI · BE

API, storage &
permissions

REPO 03Frontend/work/webAI · FE

Interface &
user experience

Reviewed API before BE + FE implementation

PM · IntegrationIndependent QC

YOU / THE DECISIONReview the evidence. Accept or request changes.

◆ You guide & accept ◆ AI coordinates & delivers Illustrative repository map

SDLC means Software Development Life Cycle.

One structured, resumable workflow. Across the repositories your product already uses.

Meet codex-sdlc

Watch the idea unfold.

Start with the introduction, then follow a feature across three repositories in the interactive walkthrough.

Explore the workflow

codex-sdlc · Introduction Watch on YouTube

Follow one feature across three repos

The handoffs.
Handled.

You describe the outcome. The PM carries context between specialists, reviews their work, and keeps one delivery record.

Illustrative walkthroughNo agents or repository changes are run on this page.

01 · REQUIREMENTS / COORDINATOR/work/requirementsShared delivery record

02 · BACKEND/work/apiAPI & backend work

03 · FRONTEND/work/webWeb interface work

01 / YOU → AI PM

Start with the outcome.

In your initialized workspace, tell Codex what you want. The PM inspects the mapped repositories and plans the work in the requirements repo.

Input: Your feature request + repository mappings
Output: One recorded run and scoped assignments

THE FEATURE REQUEST

“Let signed-in users save favorite items and find them later.”

No need to relay the same request to each role.

02 / AI BA + PM · REQUIREMENTS REPO

Make the behavior testable.

The BA turns the request into requirements, edge cases, and acceptance criteria. The PM reviews them before handing work to implementation roles.

Input: Request + repository context
Output: Reviewed requirements in the coordinator

EXAMPLE ACCEPTANCE CRITERIA

AC-01 Signed-in users can save an item.
AC-02 Favorites persist across sessions.
AC-03 A user's list is private to them.

Where does BA work live?

In the requirements repository, under .sdlc/runs/<run-id>/artifacts/ba/. This repository is the coordinator in our example.

03 / AI BACKEND + PM · API REVIEW

Agree on the connection.

Backend defines the API against reviewed requirements. Frontend implementation waits for contract review, so both sides build from the same agreed interface.

Input: Reviewed requirements
Output: Reviewed API contract for backend + frontend

EXAMPLE CONTRACT

PUT/favorites/{itemId}
GET/favorites
AUTH Return only the signed-in user's items.

◇ Gate: PM reviews the contract before implementation starts.

04 / AI BACKEND + FRONTEND · SEPARATE REPOS

Two codebases. One agreement.

Each role receives its repository, permitted paths, and reviewed inputs. Ready tasks can run in parallel when host capacity and safe scopes allow.

Input: Reviewed contract + bounded assignments
Output: Per-repository changes and implementation handoffs

ASSIGNED WORK

AI · BE

Backend repository

Favorites storage, API behavior, and access controls.

AI · FE

Frontend repository

Save control, favorites view, loading and error states.

05 / AI PM · ACROSS THE MAPPED REPOS

Check the handoffs. Connect the work.

The PM reconciles reported changes with assignments and reviewed inputs. Integration checks run against the mapped repositories and record where each command ran.

Input: Backend + frontend handoffs
Output: Integrated work and verification records for QC

Inspect the handoff chain

Requirements revision → reviewed contract → repository and assigned paths → reported changes → verification record. Inconsistent or stale handoffs need correction before acceptance.

A HANDOFF CAN BE BLOCKED

An old contract should not silently become the new truth.

Show a blocked handoff

Paused · Frontend handoff uses an older contract.

PM returns it to frontend with the current contract and assignment. The frontend role reconciles its work, reruns the required checks, and resubmits. Backend work remains recorded.

PM → Frontend → Recheck → Integration

06 / AI QC · INDEPENDENT VERIFICATION

Find the gaps. Route the repair.

QC checks the integrated feature against acceptance criteria, permissions, negative cases, and regressions. A defect goes back to the responsible role through the PM.

Input: Integrated feature + acceptance criteria
Output: QC findings, evidence, and any required rework

EXAMPLE DEFECT LOOP

Can one user read another user's favorites?

Show QC rework

Defect · Backend permission check needs repair.

QC records the failing case and evidence.
PM assigns the repair to backend in /work/api.
Backend fixes and hands off the change.
Integration checks and independent QC run again.

QC → PM → Backend → Integration → QC

Retest evidence is required before this defect can close.

07 / AI PM → YOU

The final decision stays yours.

When the required reviews and checks are complete, the PM assembles the delivery. You see what changed across repositories, what was verified, and any limitations before accepting or requesting changes.

Input: Reviewed handoffs + independent QC evidence
Output: Delivery package for human acceptance

YOUR DELIVERY PACKAGE

Changes, grouped by repository
Acceptance coverage and command evidence
Decisions, limitations, and remaining blockers

You accept the delivery or request changes.
Production deployment is a separate decision.

Step 1 of 7

Coordination you can inspect

Separate repos.
Clear ownership.
Checked handoffs.

The framework makes the boundaries explicit: where a role works, which inputs it uses, and what evidence it returns.

01 / LOCATION

Confirm the checkout.

Mappings check the Git remote and checkout root. Missing, mismatched, duplicate, or nested mappings are rejected.

Right repository, before the assignment.

02 / OWNERSHIP

Bound the assignment.

Tasks carry repository IDs and permitted paths. Handoff validation checks reported changes against ownership and protected-path rules.

Backend work has a backend scope.

03 / DEPENDENCIES

Share reviewed inputs.

Frontend waits for API review. Stale or inconsistent assignments and reports must be corrected before their handoffs are accepted.

A handoff is a checked dependency.

04 / CONTINUITY

Keep one delivery record.

Per-run locks and version checks protect published run records. Evidence identifies the working repository, and saved state supports resuming.

The next session can pick up the record.

These checks help keep changes within scope and surface invalid handoffs. They do not guarantee conflict-free work or replace your review.

An AI team with defined responsibilities

Specialists do the work.
A PM connects it.

Roles are responsibilities, not repositories. The PM and QC follow the delivery across every mapped checkout.

Coordinate the delivery

Dispatch ready work, review requirements and contracts, reconcile handoffs, and assemble the result.

Define the behavior

Turn the request into traceable requirements and acceptance criteria in the coordinator.

Build the backend

Own the assigned API, storage, and backend implementation in its mapped repository.

Build the experience

Implement web or mobile interfaces against reviewed contracts in the assigned repository.

Verify independently

Check the integrated feature, report defects, and retest the repairs.

PO · OPTIONAL

Advise on the outcome

The AI Product Owner reviews business value and acceptance coverage. Human acceptance stays with you.

Choose models by role

Start with inherited Codex settings, or use setup to configure a model and reasoning effort for each role. For example, you can request different models for frontend, backend, and QC.

These are configuration preferences; availability and dispatch depend on the Codex host. Read the model configuration guide ↗

Map once. Deliver feature by feature.

Bring your repos.
Start with an outcome.

Use your requirements or BA repository as the coordinator. Keep backend and frontend source in their own repositories, with their own Git histories.

Before setup

Node.js >=24.16.0 <25 and npm 11
Existing application checkouts accessible from your Codex session
Each mapped checkout is an independent Git root with an origin remote
Verification commands and required services available for checks

Where everything lives

The coordinator's .sdlc/ keeps the run record, BA artifacts, handoffs, and evidence. Machine-specific paths stay in ignored .sdlc/local.yaml.

Explore multi-repository setup ↗

01

Install for Codex

Add codex-sdlc from the Plugins Directory.
Open plugin page

Connect your three repositories

Open the requirements checkout in Codex. Replace the path placeholders and send:

MULTI-REPOSITORY SETUP

Set up codex-sdlc in multi-repository mode. Use this requirements repository as the coordinator. My backend checkout is at <absolute backend path>, and my frontend checkout is at <absolute frontend path>.
Inspect the applications, confirm the repository mappings and verification commands, and show the setup dry run before applying changes.

One repository? Start here instead.

Open your existing application in Codex and use:

Initialize codex-sdlc for this existing project. Explain the setup choices and show the dry run before applying changes.

Give the team a feature

After setup checks pass, send one outcome. Adapt this example to your product:

YOUR FIRST FEATURE

Start a codex-sdlc feature delivery across the mapped repositories: Let signed-in users save favorite items and find them later.
Coordinate BA, backend, frontend, integration, and independent QC. Bring the result back for my acceptance.

Prefer direct commands? Read the complete setup guide.

Before you start

The useful questions.

What does the plugin add to Codex?

It provides delivery skills for setup, PM coordination, business analysis, backend and frontend implementation, independent QC, and optional Product Owner advice. The repository runtime supplies the workflows, policies, schemas, and recorded state.

Do I need an existing application?

Yes. Initialization configures existing application directories; it does not scaffold a complete product from an empty folder. Built-in presets cover Go, Next.js, Flutter, PostgreSQL, and Redis, with generic application support for other stacks.

Why are the skills not in my project's .agents folder?

When installed from the Plugins Directory, the skills live in the Codex plugin cache. Your project receives .sdlc/ and a managed AGENTS.md block, so a project-level skills folder is not required.

What happens if the workflow pauses halfway?

The shared run record keeps assignments, evidence, decisions, and blockers. Codex asks for unclear requirements, material decisions, or approvals required by your project policy, then uses recorded state to resume. Partial work remains visible; separate repositories are not rolled back as one atomic transaction.

Can my BA repository be separate from the coordinator?

In this example, the BA repository is the coordinator. BA outputs belong under its .sdlc/runs/<run-id>/artifacts/ba/ directory. Mapping a separate documentation repository does not grant BA automatic write access to arbitrary documents there.

Does updating the plugin update my project?

No. The plugin update supplies current skills. An initialized project's pinned runtime is upgraded separately, with a dry run and rollback support. Follow the upgrade guide.

Where does delivery information live?

Configuration, requests, run manifests, reports, decisions, defects, and evidence remain in the coordinator repository under .sdlc/. Read the project's privacy guidance for details.

One request starts the work

Your next feature.
Across the repos you already have.

Install codex-sdlc Explore the source