agentic-cd — Claude Code Plugin (short acd-plugin)

A Claude Code plugin that packages the Agentic Continuous Delivery discipline as a reusable methodology identity. Based on the MinimumCD ACD specification and Dave Farley's Continuous Delivery principles.

What This Plugin Is

Your methodology identity with two layers:

• Discipline core (always active) — rules, commands, agent definitions, and hooks that constrain AI agents to follow continuous delivery discipline. Domain-agnostic.
• Domain skills (conditional, per-project) — technology-specific and practice-specific knowledge aligned with ACD discipline. Activated by /acd:init-project based on your project's needs.

The plugin's CLAUDE.md defines HOW you work. Each project gets its own CLAUDE.md (generated by /acd:init-project) that defines WHAT you work on — domain, stack, structure, constraints, and which skills are active.

The same workflow applies to any domain: software engineering, marketing, content creation, business strategy, design. The commands adapt based on the expert context — which is inferred from the intent you describe (see ADR-010).

What This Plugin Is Not

• Not project-specific configuration — that's generated per project by /acd:init-project
• Not a CI/CD pipeline — it layers on top of whatever pipeline tool you use (GitHub Actions, GitLab CI, etc.)
• Not model-specific — skills reference tiers (small, mid, frontier), not specific model names
• Not a lifecycle orchestrator — it does not decide what to build or when. It constrains how work is done. Pairs well with orchestration frameworks like nWave (see below)

Installation

# 1. Clone the repo (anywhere you like)
git clone git@github.com:DEVEDANOS/acd-plugin.git ~/.claude/plugins/acd

# 2. Run setup (registers the plugin in ~/.claude/settings.json)
cd ~/.claude/plugins/acd
bash scripts/setup-hooks.sh

# 3. Restart Claude Code, then run onboard
/acd:onboard

The setup script registers the plugin path as a local directory source and enables it. The plugin loads directly from the git repo — no copy, no build step. /acd:learn writes here, offers to commit and push. See ADR-011.

Updating

# Pull upstream changes
cd ~/.claude/plugins/acd && git pull origin main

# After updating, sync existing projects
cd your-project
/acd:sync-project

Once installed, the plugin applies to all projects. Commands are namespaced: /acd:start-session, /acd:review, etc.

Getting Started

Step 1: Onboard (once, after install)

/acd:onboard

Profiles you once — who you are, your role, goals, and domains. Persists across all projects via Claude Code's memory. Shapes how the plugin communicates and what /acd:become prioritizes.

Step 2: Initialize a project (once per project)

cd your-project
/acd:init-project

Scans your repository, asks you to confirm what it found, and generates:

• A project-specific CLAUDE.md at the project root (language, structure, constraints, active stack skills)
• Area-specific CLAUDE.md files per bounded context (if applicable)
• Pre-commit hook configuration in the project's .claude/settings.json (optional)

Also detects your technology stack and recommends available skills to activate.

Step 3: Assess capabilities (optional)

/acd:become "your project goal"

Analyzes your goal, inventories the plugin's current capabilities, identifies gaps, and proposes a learning curriculum. The plugin becomes what the work demands.

Workflow

The ACD workflow follows the MinimumCD specification. The same sequence applies to any domain — software, marketing, content, strategy, design. What changes per domain is the artifact format and quality gate, not the workflow itself.

The Universal Sequence

Step 0: /acd:init-project      Set up the project (once)
Step 1: /acd:specify            Capture intent with hypothesis, generate artifacts
Step 2: /acd:validate-spec      Check consistency across all artifacts
Step 3: /acd:start-session      Load one unit of work, assemble context
        ... work happens ...
Step 4: /acd:review             Quality gate before committing
Step 5: /acd:end-session        Validate, summarize, commit, reset context
Step 6: /acd:finalize           Archive completed feature, check hypothesis

At every step, the four-step cycle from the ACD spec applies: human drafts → agent critiques → human decides → agent refines.

How the Workflow Adapts

The intent you describe in /acd:specify determines which expert context applies. The plugin loads the relevant domain skills automatically:

Intent	Expert Context	Artifacts	Quality Gate
"Add rate limiting to /api/search"	Software engineering	BDD scenarios, code, tests	Tests pass + code review
"Write positioning brief for the agency"	Marketing	Brief, audience criteria	Review rubric + domain review
"Create a blog article about agentic CD"	Content	Draft, SEO criteria	Editorial + audience review
"Design the onboarding flow for new users"	UX/Design	Wireframes, interaction spec	Usability review

For software projects, this means BDD scenarios, ATDD/TDD double loop, and code review agents. For non-software work, the same discipline applies with domain-appropriate artifact formats and review criteria.

Additional Commands

/acd:onboard          One-time user profiling — run once after installing the plugin
/acd:fix              Pipeline-restore mode (while quality gate is red, only fix)
/acd:maintenance      Scheduled refactoring session (every 3-5 feature sessions)
/acd:security-audit   Full-codebase security audit (4 layers, schedulable)
/acd:evaluate         Evaluate knowledge through the Engineering Critical Mind
/acd:learn            Learn new knowledge — research, evaluate, create plugin artifacts
/acd:become           Goal-driven self-transformation — assess gaps, propose curriculum
/acd:sync-project     Re-sync project config with current plugin version

Software Example

You: /acd:specify
     "We believe adding rate limiting to /api/search will reduce server costs
      by 40% because 60% of current load is bot traffic."

Agent: Phase 1 — critiques intent, checks hypothesis
       Phase 2 — probes for failure modes, concurrent access, edge cases
       Phase 3 — generates BDD scenarios, feature description (Musts/Must Nots/
                 Preferences/Escalation Triggers), acceptance criteria
       Phase 4 — stress-test review

You: /acd:start-session
Agent: [assembles context, one scenario at a time]
     ... ATDD outer loop (acceptance test fails first) ...
     ... TDD inner loop (unit tests drive internals) ...
     ... acceptance test passes ...

You: /acd:review
Agent: [4 coordinating review agents: semantic, security, performance, concurrency]

You: /acd:end-session
Agent: [validates gates, writes summary, commits, resets context]

When the Quality Gate is Red

You: /acd:fix
Agent: [enters restore mode — only changes that restore the quality gate]
     ... gate passes ...

You: /acd:start-session  # back to normal

Learnings — Closing the Feedback Loop

The plugin captures knowledge that would otherwise be lost at context reset, using two mechanisms inspired by Martin Fowler's "Patterns for Reducing Friction in AI-Assisted Development":

WIP.md (Context Anchoring)

A feature spans multiple sessions. docs/wip/[feature-name].md carries decisions, discovered work, and architectural state across all sessions. Created by /acd:start-session, updated by /acd:end-session, archived into docs/evolution/ by /acd:finalize.

LEARNINGS.md (Feedback Flywheel)

When the human corrects the agent, the correction is proposed as a learning entry at /acd:end-session. Only human-approved entries are written to LEARNINGS.md at the project root. Loaded into every session's context so mistakes are not repeated.

Learnings that apply beyond the project graduate to discipline skills:

Human correction → proposed learning → approved entry → graduation to SKILL.md

Hypothesis Closure

/acd:finalize asks whether the feature's hypothesis was validated. The outcome (validated / invalidated / inconclusive / too early to tell) is recorded in the feature record alongside the evidence. This closes the loop from intent to observed outcome.

Plugin Structure

agentic-cd-plugin/
├── .claude-plugin/
│   ├── plugin.json                        # Plugin manifest (name, version, author)
│   └── marketplace.json                   # Local marketplace metadata
├── CLAUDE.md                              # Developer identity (methodology)
├── CHANGELOG.md                           # Keep a Changelog format
├── README.md                              # This file
├── LICENSE                                # Apache License 2.0
├── commands/
│   ├── init-project.md                    # /acd:init-project — generate project CLAUDE.md
│   ├── onboard.md                         # /acd:onboard — one-time user profiling
│   ├── become.md                          # /acd:become — goal-driven self-transformation
│   ├── evaluate.md                        # /acd:evaluate — critical mind analysis on any knowledge
│   ├── learn.md                           # /acd:learn — research, evaluate, create plugin artifacts
│   ├── start-session.md                   # /acd:start-session
│   ├── review.md                          # /acd:review
│   ├── end-session.md                     # /acd:end-session
│   ├── fix.md                             # /acd:fix
│   ├── specify.md                         # /acd:specify
│   ├── validate-spec.md                   # /acd:validate-spec
│   ├── maintenance.md                     # /acd:maintenance
│   ├── finalize.md                        # /acd:finalize — archive completed feature
│   ├── security-audit.md                  # /acd:security-audit — full-codebase security scan
│   └── sync-project.md                    # /acd:sync-project — re-sync project config
├── hooks/
│   └── hooks.json                         # PreToolUse hooks: file-write scope guard + agent budget
├── scripts/
│   ├── setup-hooks.sh                     # Post-clone setup (plugin registration + gitleaks hook)
│   ├── check-write-scope.sh               # Write-scope enforcement for hooks
│   ├── check-agent-max-turns.sh           # Agent execution budget enforcement
│   ├── release.sh                         # Version tagging and release
│   └── rollback.sh                        # Rollback to previous version
├── skills/
│   ├── discipline/                        # Discipline skills (ACD rules, loaded when relevant)
│   │   ├── artifact-authority/SKILL.md    # Humans own specs, agents implement
│   │   ├── becoming/SKILL.md              # Goal-driven self-transformation framework
│   │   ├── cd-discipline/SKILL.md         # CD fundamentals + ATDD/TDD in CD
│   │   ├── commit-protocol/SKILL.md       # Conventional Commits, scope rules
│   │   ├── context-hygiene/SKILL.md       # Token-aware context management
│   │   ├── critical-mind/SKILL.md         # Engineering Critical Mind — 5-step epistemological analysis
│   │   ├── ddd-architecture/SKILL.md      # DDD + hexagonal + decomposed context
│   │   ├── expert-summoning/SKILL.md      # Domain→expert agent mapping (nWave-aware, standalone fallbacks)
│   │   ├── knowledge-placement/SKILL.md   # Plugin self-anatomy + placement decision tree
│   │   ├── learnings-discipline/SKILL.md  # WIP.md + LEARNINGS.md — feedback flywheel
│   │   ├── parallel-work/SKILL.md         # Parallel scenario dispatch protocol
│   │   ├── pipeline-architecture/SKILL.md # Pipeline structure + stage ordering
│   │   ├── pipeline-restore/SKILL.md      # Constraint 8: red = restore only
│   │   ├── pipeline-speed/SKILL.md        # Pipeline optimization + cost tracking
│   │   ├── release-techniques/SKILL.md    # Feature toggles, connect last, abstraction
│   │   ├── rigor-profiles/SKILL.md        # Quality gate calibration per task risk
│   │   ├── security-pipeline/SKILL.md     # 4-layer security pipeline
│   │   ├── session-discipline/SKILL.md    # One scenario/session/commit
│   │   ├── specification-workflow/SKILL.md # Agent-assisted specification
│   │   ├── structured-outputs/SKILL.md    # JSON at every agent boundary
│   │   ├── team-coordination/SKILL.md     # Team agent usage rules
│   │   ├── test-discipline/SKILL.md       # ATDD/TDD double loop + TDD as design
│   │   └── token-budget/SKILL.md          # Model routing + cost tracking
│   ├── technology/                        # Technology skills (auto-detected)
│   │   ├── typescript/SKILL.md            # TypeScript strict practices
│   │   ├── react/SKILL.md                 # Composition, hooks, state, rendering
│   │   ├── functional/SKILL.md            # Immutability, pure functions, composition
│   │   ├── vitest/SKILL.md                # TDD inner loop engine
│   │   ├── testing-library/SKILL.md       # User-perspective component testing
│   │   ├── docker/SKILL.md                # Reproducible images, delivery artifacts
│   │   ├── accessibility/SKILL.md         # WCAG 2.1 AA testable behavior
│   │   ├── tailwindcss/SKILL.md           # Utility-first CSS, theme discipline
│   │   ├── park-ui/SKILL.md               # Park UI (Ark UI + Tailwind) headless components
│   │   ├── postgresql/SKILL.md            # Migrations, schema design, query discipline
│   │   ├── playwright/SKILL.md            # Acceptance test stage, BDD-driven E2E
│   │   ├── testcontainers/SKILL.md        # Real-service integration testing
│   │   ├── posthog/SKILL.md               # Hypothesis validation, feature flags
│   │   ├── astro/SKILL.md                 # Content-first, island architecture
│   │   ├── alpine/SKILL.md               # Progressive enhancement, localized state
│   │   ├── fastify/SKILL.md              # Plugin architecture, schema-first
│   │   ├── nestjs/SKILL.md               # Module architecture, DI, guards/pipes
│   │   ├── mikroorm/SKILL.md             # Unit of Work, migrations, entity design
│   │   ├── kysely/SKILL.md               # Type-safe SQL, migration discipline
│   │   ├── web-performance/SKILL.md      # Core Web Vitals, performance budgets
│   │   ├── nextjs/SKILL.md               # App Router, Server/Client Components
│   │   ├── react-native/SKILL.md         # FlashList, Reanimated, native navigation
│   │   └── expo/SKILL.md                 # Managed workflow, EAS, OTA updates
│   └── practices/                         # Practice skills (user-chosen)
│       ├── c4/SKILL.md
│       ├── impact-mapping/SKILL.md
│       ├── event-storming/SKILL.md
│       ├── value-metrics/SKILL.md
│       ├── pirate-metrics/SKILL.md
│       ├── technical-seo/SKILL.md
│       ├── ux-design/SKILL.md
│       └── observability/SKILL.md
├── agents/                                # 18 worker agents (no orchestrators — see ADR-004)
│   ├── implementation.md                  # Code generation (mid/frontier tier, invoked by /acd:start-session)
│   ├── semantic-review.md                 # Logic + edge cases + cross-concerns (frontier tier)
│   ├── security-review.md                 # Injection, auth, audit + cross-concerns (frontier tier)
│   ├── performance-review.md              # Timeouts, resource leaks + cross-concerns (small/mid tier)
│   ├── concurrency-review.md              # Race conditions + cross-concerns (mid tier)
│   ├── content-clarity-review.md          # Document structure + readability (mid tier)
│   ├── evidence-quality-review.md         # Claim support + factual accuracy (mid tier)
│   ├── constraint-compliance-review.md    # Constraint verification (mid tier)
│   ├── coherence-review.md               # Internal consistency + completeness (mid tier)
│   ├── expert-test-fidelity.md            # BDD-to-test alignment (mid/frontier tier, CI/CD)
│   ├── expert-implementation-coupling.md  # Behavior vs. implementation testing (mid tier, CI/CD)
│   ├── expert-architectural-conformance.md # Constraint architecture compliance (mid/frontier tier, CI/CD)
│   ├── expert-intent-alignment.md         # Implementation-to-intent match (frontier tier, CI/CD)
│   ├── expert-constraint-compliance.md    # System constraints check (mid tier, CI/CD)
│   ├── critique-clarity.md                # Spec ambiguity detection (mid tier)
│   ├── critique-testability.md            # Spec testability check (mid tier)
│   ├── critique-scope.md                  # Spec scope analysis (mid tier)
│   └── critique-consistency.md            # Spec cross-artifact consistency (mid tier)
└── docs/
    ├── adr/                               # Architecture Decision Records
    │   ├── 001-acd-nwave-relationship.md
    │   ├── 002-critical-mind-mechanism.md
    │   ├── 003-plugin-distribution-and-consumer-learning.md
    │   ├── 004-orchestration-pattern.md
    │   ├── 005-plugin-hooks.md
    │   ├── 006-nwave-architecture-mapping.md
    │   ├── 007-becoming-mechanism.md
    │   ├── 008-archetype-architecture.md
    │   ├── 009-command-namespace-compliance.md
    │   ├── 010-expert-context-workflow.md
    │   └── 011-variant-architecture.md
    └── learnings-graduation-guide.md      # Backlog file for /acd:learn --backlog

Relationship to Orchestration Frameworks

Continuous Delivery is a discipline within software engineering — not the whole of it. This plugin provides the CD discipline layer. An orchestration framework like nWave coordinates the full lifecycle (discovery, requirements, architecture, infrastructure, implementation). This plugin constrains how that work is done.

With an orchestration framework (e.g. nWave)

The orchestration framework coordinates what and when. This plugin constrains how.

Concern	Orchestration Framework	This Plugin
Orchestration	Lifecycle phases, agent sequencing	—
Session discipline	—	One scenario/session/commit
Human-owned specs	—	Human writes, agent critiques
Pipeline-restore mode	—	/acd:fix blocks new features
Review gates	Framework-specific audit trail	4 coordinating review agents with cross-pollination + rigor profiles
Context management	—	Stable-first loading, context hygiene
TDD discipline	—	Double loop ATDD/TDD, mutation testing
Architecture constraints	—	Hexagonal, DDD, coupling/cohesion
Feature traceability	Framework archive	/acd:finalize — append-only delivery records

The plugin's discipline skills apply INSIDE delivery sessions. They constrain what agents do regardless of which phase they are in. nWave is the recommended orchestration framework — see ADR-001 for the integration design.

Standalone (without an orchestration framework)

The plugin provides the full CD workflow directly: /acd:specify → /acd:start-session → /acd:review → /acd:end-session → /acd:finalize. The human plays the orchestration role — and that's where the engineering happens.

Discipline Foundation

This plugin encodes practices from:

• Continuous Delivery (Dave Farley, Jez Humble) — trunk-based development, pipeline as authority, small batches, deployment automation
• Domain-Driven Design (Eric Evans) — bounded contexts, ubiquitous language, anticorruption layers, strategic design
• Hexagonal Architecture (Alistair Cockburn) — ports & adapters as the enforcement mechanism for DDD boundaries
• Acceptance Test-Driven Development (ATDD) — the outer loop: human-written BDD scenarios drive the implementation
• Test-Driven Development (TDD) — the inner loop: red-green-refactor at the unit level
• Behavior-Driven Development (BDD) — Gherkin as a domain-specific language for behavior specification
• Domain-Specific Languages — Gherkin for behavior, CLAUDE.md for project context, area-specific CLAUDE.md for bounded context configuration
• Agentic Continuous Delivery (MinimumCD ACD specification) — the 8 constraints, six first-class artifacts with authority hierarchy, agent-assisted specification with discovery loop, hypothesis-driven development, constraint architecture (Musts/Must Nots/Preferences/Escalation Triggers), expert validation agents, replacement cycle, team agent coordination with cross-pollination

Skills

The discipline core is language-agnostic. Skills add conditional guidance per-project, activated by /acd:init-project. Three categories:

Discipline Skills (loaded when relevant)

ACD rules migrated to skills with user-invocable: false for progressive disclosure. Claude loads descriptions always (cheap) and full content only when the topic is relevant. Covers: session protocol, TDD, pipeline, DDD, security, specifications, and more.

Technology Skills (auto-detected from project files)

Skill	Detects	Provides
technology/typescript/	tsconfig.json	Type safety practices, strict mode, ACD-aligned TS patterns
technology/react/	react in dependencies	Composition, hooks, state management, rendering discipline
technology/functional/	FP libraries or conventions	Immutability, pure functions, composition patterns
technology/vitest/	vitest in devDependencies	TDD inner loop engine, watch mode, mocking discipline, test structure
technology/testing-library/	@testing-library/react in devDependencies	User-perspective testing, query priority, userEvent, async patterns
technology/docker/	Dockerfile or compose.yml	Reproducible images, multi-stage builds, compose discipline
technology/accessibility/	Any frontend framework	WCAG 2.1 AA, axe-core in tests, semantic HTML, focus management
technology/tailwindcss/	tailwindcss in dependencies	Utility-first discipline, theme as source of truth, component extraction
technology/park-ui/	@park-ui/* in dependencies	Headless-first (Ark UI behavior + Park UI styling), variant system
technology/postgresql/	pg or @mikro-orm/postgresql in dependencies	Migrations as delivery artifacts, schema design, indexing, query discipline
technology/playwright/	@playwright/test in devDependencies	Acceptance test stage (ATDD outer loop), BDD-driven E2E, AI codegen
technology/testcontainers/	testcontainers in devDependencies	Real-service integration testing, container lifecycle, migration testing
technology/posthog/	posthog-js or posthog-node in dependencies	Hypothesis validation, event tracking, feature flags, A/B experiments
technology/astro/	astro in dependencies	Content-first architecture, island architecture, Content Collections
technology/alpine/	alpinejs in dependencies	Progressive enhancement, localized reactive state, minimal JS
technology/fastify/	fastify in dependencies	Schema-first validation, plugin encapsulation, hook pipeline
technology/nestjs/	@nestjs/core in dependencies	Module architecture, DI, guards/pipes/interceptors, CQRS
technology/mikroorm/	@mikro-orm/core in dependencies	Unit of Work, Identity Map, migrations as delivery artifacts
technology/kysely/	kysely in dependencies	Type-safe SQL, migration discipline, query composition
technology/web-performance/	Any frontend project	Core Web Vitals pipeline gates, Lighthouse CI, bundle analysis
technology/nextjs/	next in dependencies	App Router, Server/Client Components, server actions, ISR/SSG/SSR
technology/react-native/	react-native in dependencies	FlashList, Reanimated, native navigation, monorepo discipline
technology/expo/	expo in dependencies	Managed workflow, EAS Build/Submit/Update, Expo Router, OTA updates

Practice Skills (chosen by the user)

Skill	Origin	Provides
practices/c4/	Simon Brown	Architecture documentation at 4 levels of zoom (Context, Container, Component, Code)
practices/impact-mapping/	Gojko Adzic	Goal → Actors → Impacts → Deliverables — upstream of /acd:specify
practices/event-storming/	Alberto Brandolini	Domain discovery through business events — feeds DDD bounded contexts
practices/value-metrics/	Lean Product	Core value metrics — does the product solve the valuable problems its users have?
practices/pirate-metrics/	Dave McClure	AARRR funnel — Acquisition, Activation, Retention, Revenue, Referral
practices/technical-seo/	Engineering discipline	Crawlability, indexability, Core Web Vitals in pipeline, structured data
practices/ux-design/	Design constraints	Design system, visual hierarchy, spacing/typography, interaction patterns
practices/observability/	Grafana/Prometheus/Loki/Sentry	Four golden signals, SLOs, structured logging, post-deployment verification

Skills are populated incrementally. Check skills.sh for existing community skills before writing from scratch.

Priority Tiers for Incremental Adoption

Priority 1 — Critical (start here)

• skills/discipline/session-discipline/ — one scenario/session/commit
• skills/discipline/artifact-authority/ — six artifacts with priority hierarchy + conflict resolution
• skills/discipline/pipeline-restore/ — constraint 8
• commands/init-project.md, start-session.md, review.md, end-session.md, fix.md
• agents/implementation.md

Priority 2 — High (add when comfortable)

• agents/semantic-review.md, security-review.md, performance-review.md, concurrency-review.md (with cross-concern checks)
• skills/discipline/context-hygiene/, structured-outputs/, token-budget/
• skills/discipline/team-coordination/ — team agent usage rules
• skills/discipline/security-pipeline/ — 4-layer security pipeline definition

Priority 3 — Recommended (adopt as desired)

• skills/discipline/cd-discipline/, ddd-architecture/, test-discipline/, specification-workflow/, rigor-profiles/
• commands/specify.md, validate-spec.md (with team critique mode), maintenance.md, finalize.md, security-audit.md
• agents/critique-clarity.md, critique-testability.md, critique-scope.md, critique-consistency.md

Priority 4 — Pipeline Integration (add when CI/CD supports it)

• agents/expert-test-fidelity.md, expert-implementation-coupling.md, expert-architectural-conformance.md, expert-intent-alignment.md, expert-constraint-compliance.md

Versioning

This plugin follows semver:

• Major — breaking changes to skill semantics or command interfaces
• Minor — new skills, commands, or agents added
• Patch — clarifications, typo fixes, wording improvements

Acknowledgments

This plugin builds on the work and ideas of many people:

• Dave Farley — Continuous Delivery, modern software engineering
• Bryan Finster — MinimumCD, Agentic CD specification
• Kent Beck — Test-Driven Development, Extreme Programming
• Eric Evans — Domain-Driven Design
• Alistair Cockburn — Hexagonal Architecture (Ports & Adapters)
• Dan North — Behavior-Driven Development
• Alberto Brandolini — Event Storming
• Gojko Adzic — Specification by Example, impact mapping
• Simon Brown — C4 model for software architecture
• Donald Schön — reflective practice, knowing-in-action
• Michael Polanyi — tacit knowledge, personal knowledge
• Emily Bache — TDD practice, coding dojo methodology
• Mike Codeur — Claude Code workflows, multi-agent orchestration, skills and agents architecture
• Anthropic — Claude Code, the platform this plugin extends

Related Projects

• nWave — Multi-agent orchestration framework for Claude Code. Coordinates the full delivery lifecycle from discovery to deployment. ACD works standalone, but using it with nWave is recommended: nWave coordinates what to build and when, ACD constrains how — session discipline, review gates, pipeline authority. See ADR-001 and ADR-006 for the integration design.
• citypaul/.dotfiles — A Claude Code configuration built around TDD, TypeScript strict mode, and functional programming patterns. Auto-discovered skills, enforcement agents, and slash commands. A different approach to the same goal: shaping how AI agents write code.
• MinimumCD Practice Guide — The Continuous Delivery body of knowledge this plugin is built on. The Agentic CD specification defines the 8 constraints that ACD enforces.
• MinimumCD Resources — Books, talks, and further reading on Continuous Delivery practices.

Spec Compliance

Every file maps to a specific page of the ACD specification. The mapping is documented in the audit report.

License

Apache License 2.0 — see LICENSE for the full text.

Why Apache 2.0? It provides an explicit patent grant (contributors can't patent-troll users of their contributions) and trademark protection (the DEVEDANOS name and brand remain protected). It's permissive enough that anyone can use, modify, and distribute the plugin — including in commercial projects — while maintaining clear attribution.

Copyright 2026 S NOBOUR SASU — DEVEDANOS®