ADLC Team Skills — Agentic SDLC for Engineering Teams

Stop Vibe Coding in Silos. Build a Shared Cognitive Layer for Your Engineering Team.

Individual prompt hacks create quick wins for solo developers, but when scaled across a team, "vibe coding" leads to chaotic technical debt, context rot, unreviewable PRs, and lost code ownership. Speed is solved; Trust and Verification is the new bottleneck in AI engineering.

ADLC Team Skills (tikalk/adlc-team-skills) is the open-source Team Layer of the Twelve-Factor Agentic SDLC. It turns AI agents from isolated guessers into compliant, accountable team members that share your team's constitution, product strategy, architectural standards, and evaluation benchmarks.

Team AI Directives (tikalk/agentic-sdlc-team-ai-directives) is the companion repository that holds your team's version-controlled context modules (constitution, rules, personas, examples), CDR index, and skills manifest.

Quickstart

# Install skills + generate slash commands + wire session_start events
npx adlc-skills-cli add tikalk/adlc-team-skills -a opencode

# Or with npx skills only (skills without commands/events)
npx skills add tikalk/adlc-team-skills -a claude -g

Works out of the box with any agent supporting the Agent Skills standard — Claude Code, Codex, OpenCode, Cursor, GitHub Copilot, and others.

Slash commands + events: adlc-skills-cli wraps npx skills add and additionally generates /name slash commands and wires session_start event hooks (via .events.json) for 9 coding agents. Skills repos without .events.json get commands only.

Universal orchestration: mission-brief auto-discovers skills from any source (mattpocock/skills, addy osmani/agent-skills, superpowers, spec-kit, or your own) and dynamically wires them into the mission pipeline. No vendor lock-in.

Golden path — bootstrap a new team-ai-directives

team-boot auto-runs at session start via the event hook. On an unconfigured project it outputs a warning telling the user to run /team-setup. team-setup is also available on demand:

npx adlc-skills-cli add tikalk/adlc-team-skills -a opencode   # install skills + commands + events

Then choose Mode 3 — Scaffold new empty team-ai-directives, or Mode 1 — Clone from GitHub to fork tikalk/agentic-sdlc-team-ai-directives:

team-setup            → pick destination (default ./team-ai-directives) + team name
                      → scaffolds README / AGENTS.md / CDR.md / .skills.json /
                        constitution placeholder / OKF index files + git init

team-constitution     → interactively replace the placeholder with your real principles

team-boot (auto)      → assembles constitution + CDR index + PDR/ADR indexes + skills registry
                        into the system prompt at session start

Already have a directives repo? team-setup offers three other modes:

• Mode 1 — Clone from GitHub (e.g. fork tikalk/agentic-sdlc-team-ai-directives)
• Mode 2 — Point to existing local path (wire a repo you already have)
• Mode 4 — Already configured (verify an existing setup)

How It Works: Before vs. After ADLC

Directives as Code: The Four Team Pillars

                             [ THE GREAT FILTER ]
                      (Human Team Lead Macro-Review)
                                     ▲
                                     │
                  ┌──────────────────┴──────────────────┐
                  │   Pillar 4: Governance & Evals      │
                  │   (Tier 1 Fast Checks + LLM Judges) │
                  └──────────────────▲──────────────────┘
                                     │
                  ┌──────────────────┴──────────────────┐
                  │   Pillar 3: Spec-Driven Workflow    │
                  │   (Contract-First Mission Pipeline) │
                  └──────────────────▲──────────────────┘
                                     │
                  ┌──────────────────┴──────────────────┐
                  │   Pillar 2: Product & Architecture  │
                  │   (Product PDRs + Architecture ADRs)│
                  └──────────────────▲──────────────────┘
                                     │
                 ┌───────────────────┴───────────────────┐
                 │   Pillar 1: Strategy & Team Directives│
                 │   (team-boot / levelup / CDR repository) │
                 └───────────────────────────────────────┘

🏛️ Pillar 1: Strategy & Team Directives (Team-First Alignment)

Put the team at the center of your AI strategy. Instead of individual developers hoarding prompt shortcuts on local machines, team standards live in a version-controlled Git repository (team-ai-directives).

• team-boot: Auto-runs at session start via the event hook, assembling the team constitution, CDR index, PDR/ADR indexes, and skill registry into the system prompt.
• Progressive Disclosure (No Token Waste): Instead of dumping massive prompt walls into every session, team-boot injects a compact ~100-token index. team-discover loads full rule bodies only when relevant to the active task.
• team-constitution: Interactively define, review, or amend your engineering team's core principles.
• team-repair: Re-index CDR.md, scan for rule conflicts, and verify directive freshness.

team-boot        → assembles constitution + CDR index + PDR/ADR + skills into system prompt
team-discover    → manual re-scan for structured discovery tables (/team-discover)
team-constitution → create or amend the team constitution interactively
team-repair      → re-index CDR.md, scan for conflicts, verify freshness

🎯 Pillar 2: Product Strategy & Architectural Governance (PDRs & ADRs)

Without documented decisions, every implementation session re-derives (or misinterprets) product intent and architectural rules.

• Product Decision Records (product-*): Capture product decisions as individual PDR files, resolve ambiguities through an interactive clarification workflow, and compile them into a self-contained PRD.md.
• Architectural Decision Records (architect-*): Reverse-engineer or define architectural decisions using Rozanski & Woods viewpoints (Functional, Security, Deployment, Performance) and compose them into a unified AD.md.
• product-roadmap: Track milestone progress across four layers of truth — decisions (PDRs), execution (live issues via MCP), code evidence, and milestone gates.

Product:      product-init → product-clarify → product-implement → product-analyze
Architecture: architect-init → architect-clarify → architect-implement → architect-analyze
Roadmap:      product-roadmap (tracks PDRs + issues + code + gates)

📐 Pillar 3: Spec-Driven Workflow ("Debug the Spec, Not the Code")

AI is an obsessive guesser — when faced with ambiguity, it invents solutions instead of asking questions. Move from a Conversational model to a Contract model.

• mission-brief: The team's autonomous pipeline runner. Takes a feature prompt, derives a formal contract (Goal, Constraints, Non-Goals, Success Criteria), generates an ordered step list, and walks a specify → plan → tasks → implement ↺ converge loop to completion.
• Mantra: "Debug the Spec, Not the Code": When an agent makes a mistake, don't just patch the code — add the missing constraint to the specification so the mistake is never repeated.

mission-brief "add user profile API with JWT"
  ├── Phase 2: Brief (Goal, Constraints, Non-Goals, Success Criteria)
  ├── Phase 3: Route Classification (spec | change | quick)
  ├── Phase 4: Discovery (auto-wires local installed skills & SDD frameworks)
  └── Phase 5: Execute (specify → plan → tasks → implement ↺ converge)

🛡️ Pillar 4: Team Governance, Verification-First Evals & "Build to Delete"

Never let the agent that wrote the code decide if the code is good. "Separate the Maker from the Checker."

• evals skills: Build application-level evaluation suites (PromptFoo or DeepEval) using Eval-Driven Development (EDD). Runs Tier 1 fast checks + Tier 2 LLM judge subagents to test code against defined business risks before human macro-review in The Great Filter.
• levelup: Capture session wins into permanent team memory. levelup-specify extracts session execution