{"slug": "agent-skills-that-bring-team-coding-standards-to-claude-code-and-codex", "title": "Agent skills that bring team coding standards to Claude Code and Codex", "summary": "Tikal released ADLC Team Skills, an open-source team layer for the Twelve-Factor Agentic SDLC, designed to bring team coding standards to AI coding agents such as Claude Code, Codex, OpenCode, Cursor, and GitHub Copilot. The toolkit includes slash commands, session-start event hooks, and a companion repository for version-controlled team directives, aiming to replace chaotic 'vibe coding' with compliant, accountable AI-assisted development.", "body_md": "Stop Vibe Coding in Silos. Build a Shared Cognitive Layer for Your Engineering Team.\n\nIndividual 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.**\n\n**ADLC Team Skills** (`tikalk/adlc-team-skills`\n\n) 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.\n\n**Team AI Directives** ([ tikalk/agentic-sdlc-team-ai-directives](https://github.com/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.\n\n```\n# Install skills + generate slash commands + wire session_start events\nnpx adlc-skills-cli add tikalk/adlc-team-skills -a opencode\n\n# Or with npx skills only (skills without commands/events)\nnpx skills add tikalk/adlc-team-skills -a claude -g\n```\n\nWorks out of the box with any agent supporting the [Agent Skills standard](https://agentskills.io) — Claude Code, Codex, OpenCode, Cursor, GitHub Copilot, and others.\n\n**Slash commands + events:** [ adlc-skills-cli](https://github.com/tikalk/adlc-skills-cli) wraps\n\n`npx skills add`\n\nand additionally generates `/name`\n\nslash commands and wires `session_start`\n\nevent hooks (via `.events.json`\n\n) for 9 coding agents. Skills repos without `.events.json`\n\nget commands only.**Universal orchestration:** `mission-brief`\n\nauto-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.\n\n`team-boot`\n\nauto-runs at session start via the event hook. On an unconfigured project it outputs a warning telling the user to run `/team-setup`\n\n. `team-setup`\n\nis also available on demand:\n\n```\nnpx adlc-skills-cli add tikalk/adlc-team-skills -a opencode   # install skills + commands + events\n```\n\nThen choose **Mode 3 — Scaffold new empty team-ai-directives**, or **Mode 1 — Clone from GitHub** to fork [ tikalk/agentic-sdlc-team-ai-directives](https://github.com/tikalk/agentic-sdlc-team-ai-directives):\n\n```\nteam-setup            → pick destination (default ./team-ai-directives) + team name\n                      → scaffolds README / AGENTS.md / CDR.md / .skills.json /\n                        constitution placeholder / OKF index files + git init\n\nteam-constitution     → interactively replace the placeholder with your real principles\n\nteam-boot (auto)      → assembles constitution + CDR index + PDR/ADR indexes + skills registry\n                        into the system prompt at session start\n```\n\nAlready have a directives repo? `team-setup`\n\noffers three other modes:\n\n**Mode 1 — Clone from GitHub**(e.g. fork)`tikalk/agentic-sdlc-team-ai-directives`\n\n**Mode 2 — Point to existing local path**(wire a repo you already have)** Mode 4 — Already configured**(verify an existing setup)\n\n| Without ADLC (Vibe Coding) | With ADLC Team Skills |\n|---|---|\nSession starts from zero: Agent knows nothing about your architecture, team rules, or deprecated patterns. |\nAuto-bootstrapped context: `team-boot` auto-loads your Team Constitution & active decisions on session start. |\nPrompt wall bloat: Dumping a 10,000-token prompt wall wastes tokens and causes model instruction drift. |\nProgressive disclosure: `team-boot` injects a ~100-token index; `team-discover` fetches only the 1–2 rules relevant to the task. |\nAmbiguity leads to guessing: Agent invents functions or database schema instead of asking questions. |\nContract-first specs: `mission-brief` defines Goal, Constraints, Non-Goals, and Success Criteria before writing code. |\nLearnings evaporate: Debugging fixes and newly discovered edge cases disappear when the chat ends. |\nClosed feedback loop: `levelup-specify` extracts session execution traces and commits new rules directly to Git. |\nSilent regressions: Prompt edits or base model updates silently degrade agent output. |\nVerification-first evals: Automated LLM judges and binary graders test code against business risks before human review. |\n\n```\n                             [ THE GREAT FILTER ]\n                      (Human Team Lead Macro-Review)\n                                     ▲\n                                     │\n                  ┌──────────────────┴──────────────────┐\n                  │   Pillar 4: Governance & Evals      │\n                  │   (Tier 1 Fast Checks + LLM Judges) │\n                  └──────────────────▲──────────────────┘\n                                     │\n                  ┌──────────────────┴──────────────────┐\n                  │   Pillar 3: Spec-Driven Workflow    │\n                  │   (Contract-First Mission Pipeline) │\n                  └──────────────────▲──────────────────┘\n                                     │\n                  ┌──────────────────┴──────────────────┐\n                  │   Pillar 2: Product & Architecture  │\n                  │   (Product PDRs + Architecture ADRs)│\n                  └──────────────────▲──────────────────┘\n                                     │\n                 ┌───────────────────┴───────────────────┐\n                 │   Pillar 1: Strategy & Team Directives│\n                 │   (team-boot / levelup / CDR repository) │\n                 └───────────────────────────────────────┘\n```\n\nPut 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](https://github.com/tikalk/agentic-sdlc-team-ai-directives)).\n\n: 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.`team-boot`\n\n**Progressive Disclosure (No Token Waste)**: Instead of dumping massive prompt walls into every session,`team-boot`\n\ninjects a compact ~100-token index.`team-discover`\n\nloads full rule bodies*only*when relevant to the active task.: Interactively define, review, or amend your engineering team's core principles.`team-constitution`\n\n: Re-index CDR.md, scan for rule conflicts, and verify directive freshness.`team-repair`\n\n```\nteam-boot        → assembles constitution + CDR index + PDR/ADR + skills into system prompt\nteam-discover    → manual re-scan for structured discovery tables (/team-discover)\nteam-constitution → create or amend the team constitution interactively\nteam-repair      → re-index CDR.md, scan for conflicts, verify freshness\n```\n\nWithout documented decisions, every implementation session re-derives (or misinterprets) product intent and architectural rules.\n\n**Product Decision Records (**: Capture product decisions as individual PDR files, resolve ambiguities through an interactive clarification workflow, and compile them into a self-contained`product-*`\n\n)`PRD.md`\n\n.**Architectural Decision Records (**: Reverse-engineer or define architectural decisions using Rozanski & Woods viewpoints (Functional, Security, Deployment, Performance) and compose them into a unified`architect-*`\n\n)`AD.md`\n\n.: Track milestone progress across four layers of truth — decisions (PDRs), execution (live issues via MCP), code evidence, and milestone gates.`product-roadmap`\n\n```\nProduct:      product-init → product-clarify → product-implement → product-analyze\nArchitecture: architect-init → architect-clarify → architect-implement → architect-analyze\nRoadmap:      product-roadmap (tracks PDRs + issues + code + gates)\n```\n\nAI is an obsessive guesser — when faced with ambiguity, it invents solutions instead of asking questions. Move from a *Conversational* model to a *Contract* model.\n\n: 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`mission-brief`\n\n`specify → plan → tasks → implement ↺ converge`\n\nloop 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.\n\n```\nmission-brief \"add user profile API with JWT\"\n  ├── Phase 2: Brief (Goal, Constraints, Non-Goals, Success Criteria)\n  ├── Phase 3: Route Classification (spec | change | quick)\n  ├── Phase 4: Discovery (auto-wires local installed skills & SDD frameworks)\n  └── Phase 5: Execute (specify → plan → tasks → implement ↺ converge)\n```\n\nNever let the agent that wrote the code decide if the code is good. \"Separate the Maker from the Checker.\"\n\n: 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`evals`\n\nskills*before*human macro-review in**The Great Filter**.: Capture session wins into permanent team memory.`levelup`\n\n`levelup-specify`\n\nextracts session execution traces and commits them to Git as reusable rules (Context Directive Records — CDRs).**\"Build to Delete\"**: Prune outdated rules and prompt scaffolding as underlying foundation models improve using`team-repair --build-to-delete`\n\n.\n\n```\nLevelUp: levelup-init → levelup-specify → levelup-clarify → levelup-publish\nEvals:   evals-init → evals-specify → evals-clarify → evals-implement → evals-validate → evals-analyze\n```\n\n**Factor XII — Build to Delete. Factor XIII — Loop Engineering.**\n\n`mission-brief`\n\nacts as an open, vendor-agnostic orchestrator across all popular agent skill repositories and Spec-Driven Development (SDD) frameworks:\n\n| SDD Framework / Skill Source | Supported Workflows |\n|---|---|\nAgentic SDLC Spec-Kit (`tikalk/agentic-sdlc-spec-kit` ) |\nTwelve-Factor SDD pipeline, native specify CLI discovery, contract verification |\nSpec-Kit (`specify_cli` ) |\nNative command discovery and specification templates |\nOpenSpec |\nStructured edge-case contracts and verification schemas |\n|\n`/tdd` , `/grill-me` , `/grill-with-docs` , `/code-review` , `/prototype` |\n|\nExit criteria checklists, quality gate skills |\n|\nDeveloper tooling & workflow skills |\nADLC Team Skills (this repo) |\n`product-specify` , `architect-specify` , `evals-validate` , `levelup-specify` |\nYour Custom Skills |\nAny skill following the `SKILL.md` standard |\n\n**Discovery**— At mission start,`mission-brief`\n\nscans all skills directories (`.claude/skills`\n\n,`.agents/skills`\n\n, etc.) and reads every`SKILL.md`\n\nfrontmatter to build a vendor-agnostic inventory of installed skills with their names and descriptions.**LLM-decided routing**— Each step's delegation prompt includes the full skills inventory. The subagent decides which skill (if any) fits the current phase — the LLM matches, not a brittle lookup table.**Graceful fallback**— If no skill matches, the subagent executes directly. If a skill matches, it's invoked. Either way, the mission pipeline continues.\n\n```\n# Install skills from multiple team or community sources\nnpx skills add mattpocock/skills\nnpx skills add tikalk/adlc-team-skills\n\n# mission-brief discovers and routes them automatically\nmission-brief \"add user profile API with JWT\"\n```\n\nSkills are organized under the four pillars of the Twelve-Factor Agentic SDLC, flattened directly under the `skills/`\n\ndirectory:\n\n```\nskills/\n├── architect/             # architect-* (5 skills)\n├── product/               # product-* (6 skills) + product-templates/\n├── levelup/               # levelup-* (4 skills) + levelup-helpers.{sh,ps1}\n├── mission-brief/         # core SDD orchestrator (1 skill)\n├── evals/                 # evals-* (6 skills) + evals-templates/\n├── tech-radar/            # tech-radar-* (1 skill) + resources/radar.json\n├── workspace/             # workspace (1 skill) — multi-repo coordination\n└── team/                  # team-* (6 skills) + team-helpers.{sh,ps1}\n```\n\nThis places every single skill exactly 2 levels deep, fully resolving the default depth limit of the `skills`\n\nCLI and ensuring all skills install out of the box.\n\n— Bootstrap session: assembles constitution, CDR index, PDR/ADR indexes, and skill registry into the system prompt at session start. Outputs a warning to run`team-boot`\n\n`/team-setup`\n\non unconfigured projects.— Manually re-scan team context modules and produce a structured discovery table. Available via`team-discover`\n\n`/team-discover`\n\n.— Clone, scaffold, or configure a team AI directives repository. Model-invoked by`team-setup`\n\n`team-boot`\n\n(self-install) and available on demand. Say \"Set up team directives for this project.\"\n\n— Create or amend the team constitution interactively. Say \"Create our team constitution\" or \"Amend our team principles.\"`team-constitution`\n\n— Re-index CDR.md, .skills.json, AGENTS.md; health check; conflict scan; freshness verification. Say \"Check our team directives health\" (`team-repair`\n\n`--health-only`\n\n), \"Repair our CDR index,\" or \"Scan for rule conflicts\" (`--conflicts`\n\n).— Browse and install team skills from the team AI directives. Say \"Show me available team skills.\"`team-skills`\n\nAll user-invoked. Capture and publish reusable patterns to team-ai-directives, including paired directive compliance evals.\n\n— Brownfield CDR discovery from existing codebase, including paired eval CDRs from code patterns. Say \"Discover directives from this codebase.\"`levelup-init`\n\n— Extract CDRs and paired eval CDRs from the current session. Say \"Extract lessons from this session.\"`levelup-specify`\n\n— Review, accept, reject, or defer pending CDRs. Evals regression gate runs by default. Say \"Review pending CDRs.\"`levelup-clarify`\n\n— Compile accepted CDRs into team directives artifacts, evals goldensets, and draft PR. Say \"Publish accepted CDRs\" or \"Build one skill from a CDR\" (`levelup-publish`\n\n`--skill CDR-NNN`\n\n).\n\nAll user-invoked. Document product decisions as individual PDRs and compile into a self-contained PRD.md.\n\n— Brownfield PDR discovery from existing codebase and documentation. Say \"Discover product decisions from this codebase.\"`product-init`\n\n— Greenfield PDR creation through interactive product exploration. Say \"Let's define our product strategy.\"`product-specify`\n\n— Refine, validate, and approve PDRs before PRD generation. Say \"Review our product decisions.\"`product-clarify`\n\n— Generate PRD.md from accepted PDRs (multi-agent DAG orchestration). Say \"Generate our PRD.\"`product-implement`\n\n— Read-only PDR↔PRD consistency and quality analysis. Say \"Analyze our product docs.\"`product-analyze`\n\n— Track milestone progress: decision status, live issues via MCP, code evidence, and gates. Say \"Show roadmap progress.\"`product-roadmap`\n\nAll user-invoked. Create and manage Architecture Decision Records using the Rozanski & Woods methodology.\n\n— Reverse-engineer ADRs from an existing codebase (brownfield). Say \"Reverse-engineer architecture from this codebase.\"`architect-init`\n\n— Create ADRs from a PRD or feature description (greenfield). Say \"Create ADRs from this PRD.\"`architect-specify`\n\n— Refine and validate existing ADRs. Say \"Refine and validate my ADRs.\"`architect-clarify`\n\n— Generate an Architecture Description (AD.md) from accepted ADRs. Say \"Generate AD.md from my ADRs.\"`architect-implement`\n\n— Check ADR↔AD consistency and architecture quality. Say \"Analyze architecture consistency.\"`architect-analyze`\n\nAll user-invoked. Build and maintain application-level evaluation suites following EDD (Eval-Driven Development) principles (PromptFoo or DeepEval).\n\n— Initialize evaluation directory structure (`evals-init`\n\n`evals/{system}/`\n\n) with security baseline. Say \"Initialize my evaluation harness.\"— Extract eval criteria from specs and production failure traces (bottom-up open coding). Say \"Specify evaluation criteria from this failure log.\"`evals-specify`\n\n— Cluster related patterns, refine criteria, isolate 20% holdout split, and publish goldset. Say \"Clarify and accept my draft evaluations.\"`evals-clarify`\n\n— Generate executable graders and test configs, automatically running unit tests to verify evaluator correctness. Say \"Generate graders from the goldset.\"`evals-implement`\n\n— Run the evaluation pyramid (Tier 1 fast checks + Tier 2 LLM judges) and compute quality metrics (TPR/TNR, SLA headroom). Say \"Validate my evaluation suite.\"`evals-validate`\n\n— Deep-analyze trajectory failure traces, routing spec-level failures to`evals-analyze`\n\n`levelup-specify`\n\n(rules) and generalization failures to backlog. Say \"Analyze evaluation failures.\"\n\nUser-invoked. Structure a feature description into a Mission Brief and run it end-to-end with any installed SDD skill set.\n\n— Takes a description, structures it into a Mission Brief (goal, constraints, success criteria), generates an ordered step list with prompts that trigger installed SDD skills, and walks those steps to converged implementation. Sync (gated) or`mission-brief`\n\n`--async`\n\n(ungated, checkpoint across sessions). Say \"Build this feature end to end\" or`mission-brief \"add dark mode\"`\n\n. Resume with`mission-brief --resume`\n\n.\n\nModel-invoked. Grounds tech stack choices in Tikal's Israeli Tech Radar.\n\n— Discovers technologies implied by the prompt, matches them against the Tikal Tech Radar (`tech-radar-context`\n\n`radar.json`\n\n), and injects a context table with each technology's adoption ring (`Keep`\n\n/`Start`\n\n/`Try`\n\n/`Stop`\n\n), quadrant, and Tikal's \"Why?\" opinion — plus Tikal-aligned alternatives for anything on`Stop`\n\n. Auto-triggered whenever a technology, framework, database, library, or cloud tool is being chosen or evaluated. Fetches the live radar best-effort and falls back to a bundled snapshot at`resources/radar.json`\n\n.\n\nUser-invoked. Multi-repo workspace coordination for shared team context.\n\n— Discover child repos at depth 1 and optionally link them as Git submodules, creating a multi-repo workspace analogous to VS Code's`workspace`\n\n`.code-workspace`\n\n. The parent repo holds shared PDRs, ADRs, and CDRs under`.adlc/`\n\n(created by`product-specify`\n\n,`architect-specify`\n\n,`levelup-specify`\n\n); child implementation repos are linked for unified context. Commands:`/workspace`\n\n(discover),`/workspace --link`\n\n(register submodules),`/workspace --status`\n\n(audit: branch, dirty, unpushed, SHA drift). No`workspace.yml`\n\n— pure auto-discovery by convention. Say \"Set up multi-repo workspace\" or`/workspace --link`\n\n.\n\n**Output File Layout**\n\nAll skills write to `.adlc/`\n\n(project root) and the team AI directives repo.\n\n**Team Directives** (inside the team AI directives repository):\n\n`AGENTS.md`\n\n— agent instructions (loading order, rules, skills)`CDR.md`\n\n— index of approved context contributions`.skills.json`\n\n— skills manifest (schema v2.0.0)`.mcp.json.example`\n\n— MCP servers config example`context_modules/constitution.md`\n\n— team constitution (OKF frontmatter)`context_modules/{rules,personas,examples}/**/*.md`\n\n— context modules`context_modules/{type}/index.md`\n\n— progressive disclosure per concept type`context_modules/{type}/log.md`\n\n— chronological change log per concept type`skills/{name}/SKILL.md`\n\n+`.skills-entry.json`\n\n— published team skills`evals/{directive-id}/goldset.md`\n\n+`goldset.json`\n\n— directive compliance goldensets\n\n**LevelUp** (inside `.adlc/`\n\nof the target project):\n\n`.adlc/drafts/cdr/CDR-{NNN}.md`\n\n— proposed/discovered CDRs (including eval CDRs)`.adlc/drafts/cdr/cdr.md`\n\n— auto-generated CDR index`.adlc/init-options.json`\n\n— team AI directives path config\n\n**Product** (inside `.adlc/`\n\nand repo root):\n\n`.adlc/drafts/pdr/PDR-{NNN}.md`\n\n— proposed/discovered PDRs`.adlc/drafts/pdr/pdr.md`\n\n— auto-generated PDR index`.adlc/memory/pdr/PDR-{NNN}.md`\n\n— accepted/completed PDRs`.adlc/memory/pdr/pdr.md`\n\n— accepted PDR index`.adlc/product/sections/{feature-area}/{section}.md`\n\n— PRD section build artifacts`.adlc/product/state.json`\n\n— DAG execution state`PRD.md`\n\n— Product Requirements Document (repo root)\n\n**Architecture** (inside `.adlc/`\n\nand repo root):\n\n`.adlc/drafts/adr/ADR-{NNN}.md`\n\n— proposed/discovered ADRs`.adlc/drafts/adr/adr.md`\n\n— auto-generated ADR index`.adlc/memory/adr/ADR-{NNN}.md`\n\n— accepted ADRs`.adlc/memory/adr/adr.md`\n\n— accepted ADR index`AD.md`\n\n— Architecture Description (repo root)`.adlc/architect/`\n\n— per-view DAG artifacts\n\n**Missions** (inside `.adlc/`\n\nof the target project):\n\n`.adlc/workflow/workflow-config.yml`\n\n— mission execution/supervision/budgets config`.adlc/workflow/.mission-state.json`\n\n— step list, completed steps, brief, discovery results`.adlc/workflow/runs/<feature>/mission-log.json`\n\n— final audit trail`.adlc/workflow/runs/<feature>/iterations.md`\n\n— per-implement audit entries\n\n**Governance** (inside target project and repo root):\n\n`.adlc/drafts/evals/EVAL-{NNN}.md`\n\n— proposed/discovered eval criteria drafts`.adlc/drafts/evals/evals.md`\n\n— draft evals index`.adlc/memory/evals/EVAL-{NNN}.md`\n\n— accepted/completed eval criteria`.adlc/memory/evals/evals.md`\n\n— accepted evals index`.adlc/memory/evals/holdout.json`\n\n— isolated/reserved holdout test dataset`evals/{system}/goldset.md`\n\n— published goldset (human-readable)`evals/{system}/goldset.json`\n\n— published goldset (machine-readable)`evals/{system}/config.yml`\n\n— evaluation framework configuration`evals/{system}/config.{js,py}`\n\n— framework test config`evals/{system}/graders/check_*.py`\n\n— generated binary Python graders / metrics`evals/{system}/tests/test_check_*.py`\n\n— generated unit tests verifying grader correctness`evals/results/validation_report.md`\n\n— statistical validation results report\n\n**Workspace** (inside parent repo root):\n\n`.gitmodules`\n\n— Git submodule registrations for child repos (created by`--link`\n\n)`.adlc/`\n\n— shared team context (PDRs, ADRs, CDRs); parent is the single source of truth- Child repos discovered at depth 1; each child's\n`.adlc/`\n\npresence is reported (informational)\n\n**OKF Compliance**\n\nGenerated context modules include [Open Knowledge Format (OKF) v0.1](https://blog.agentics.org/open-knowledge-format/) compliant frontmatter alongside custom fields.\n\n| OKF field | Status | Source |\n|---|---|---|\n`type` |\n✅ | CDR context type |\n`title` |\n✅ | CDR title |\n`description` |\n✅ | CDR descriptor |\n`resource` |\n✅ | Relative path to artifact |\n`tags` |\n✅ | Context type tag |\n`timestamp` |\n✅ | ISO 8601 datetime |\n\nCustom fields co-exist with OKF frontmatter: `id`\n\n, `cdr_ref`\n\n, `created`\n\n, `modified`\n\n, `verified`\n\n, `age_days`\n\n, `evidence`\n\n.\n\nDirectory structure: `context_modules/{type}/index.md`\n\n(progressive disclosure), `context_modules/{type}/log.md`\n\n(change history), cross-links between related concepts.\n\n**Workflows**\n\n**Team Directives setup:**\n\n```\nteam-setup → team-constitution → team-boot (auto at session start)\n```\n\n**Product lifecycle:**\n\n```\nBrownfield: product-init → product-clarify → product-implement → product-analyze\nGreenfield: product-specify → product-clarify → product-implement → product-analyze\nRoadmap:    product-roadmap (anytime)\n```\n\n**Architecture lifecycle:**\n\n```\nBrownfield: architect-init → architect-clarify → architect-implement → architect-analyze\nGreenfield: architect-specify → architect-clarify → architect-implement → architect-analyze\n```\n\n**LevelUp / CDR lifecycle:**\n\n```\nBrownfield: levelup-init → levelup-clarify → levelup-publish → team-repair\nSession:    levelup-specify → levelup-clarify → levelup-publish → team-repair\nBuild to Delete: team-repair --build-to-delete → levelup-clarify (review deletion CDRs)\n```\n\n**Mission:**\n\n```\nmission-brief \"feature\" → review brief → execute steps → converge → mission-log.json\n```\n\n**Multi-repo workspace:**\n\n```\nproduct-specify / architect-specify → create shared PDRs/ADRs in parent .adlc/\nworkspace --link → register child repos as submodules\nworkspace --status → audit branch, dirty, unpushed, SHA drift\n```\n\n**Application Evaluation lifecycle:**\n\n```\nGreenfield (Spec-Driven): evals-init → evals-specify (from spec) → evals-clarify → evals-implement → evals-validate\nBrownfield (Error-Driven): evals-init → evals-specify (from failures) → evals-clarify → evals-implement → evals-validate → evals-analyze\n```\n\n**Full product → architecture → team:**\n\n```\nProduct:     product-specify → product-clarify → product-implement → product-analyze\nArchitecture: architect-specify → architect-clarify → architect-implement → architect-analyze\nTeam:        levelup-specify → levelup-clarify → levelup-publish → team-repair\n```\n\n**12-Factor Alignment**\n\n| Factor | Skills | How |\n|---|---|---|\nIII — Mission Definition |\nProduct skills | PRD/PDR lifecycle ensures product decisions are documented, reviewed, and traceable before execution |\nIV — Structured Planning |\nArchitecture skills | ADRs and AD.md provide structured planning artifacts using Rozanski & Woods viewpoints |\nVII — Verification-First Evals |\nLevelUp + Evals skills | LevelUp creates directive-compliance eval CDRs; evals skills build and run application-level evaluation suites (PromptFoo/DeepEval) with binary graders, holdout splits, and statistical validation |\nVIII — Ratchet Effect |\nLevelUp + Evals skills | Each session extracts eval CDRs alongside directive CDRs; each goldset publication adds criteria that monotonically increase quality — `evals-clarify` publishes, `evals-validate` enforces |\nIX — Traceability |\nProduct + Architecture | Every decision traces from PDR → PRD → feature and from ADR → AD → code |\nX — Context Engineering |\nTeam Directives | `team-boot` assembles constitution, CDR index, and PDR/ADR indexes into the system prompt at session start; `team-discover` provides manual re-scan |\nXI — Directives as Code |\nTeam + LevelUp + Product + Architecture | All directive lifecycles (CDR, PDR, ADR) live in version-controlled repos, each with draft → clarify → accept → publish → analyze stages |\nXII — Build to Delete |\nteam-repair + evals-analyze | `--build-to-delete` runs evals without directives via LLM calls; if model passes, proposes deletion (Harness Decay); `evals-analyze` routes spec failures to `levelup-specify` (rules) and generalization failures to the evaluator backlog — the feedback loop that makes build-to-delete verifiable |\n\nSee [RELEASE.md](/tikalk/adlc-team-skills/blob/main/RELEASE.md) for the release runbook, tag naming conventions, and recovery procedures.\n\nMIT — see [LICENSE](/tikalk/adlc-team-skills/blob/main/LICENSE).", "url": "https://wpnews.pro/news/agent-skills-that-bring-team-coding-standards-to-claude-code-and-codex", "canonical_source": "https://github.com/tikalk/adlc-team-skills", "published_at": "2026-08-04 14:38:31+00:00", "updated_at": "2026-08-04 15:40:48.002548+00:00", "lang": "en", "topics": ["developer-tools", "ai-agents", "ai-tools"], "entities": ["Tikal", "ADLC Team Skills", "Claude Code", "Codex", "OpenCode", "Cursor", "GitHub Copilot", "Twelve-Factor Agentic SDLC"], "alternates": {"html": "https://wpnews.pro/news/agent-skills-that-bring-team-coding-standards-to-claude-code-and-codex", "markdown": "https://wpnews.pro/news/agent-skills-that-bring-team-coding-standards-to-claude-code-and-codex.md", "text": "https://wpnews.pro/news/agent-skills-that-bring-team-coding-standards-to-claude-code-and-codex.txt", "jsonld": "https://wpnews.pro/news/agent-skills-that-bring-team-coding-standards-to-claude-code-and-codex.jsonld"}}