convez.ai
SkillDesenvolvimento WebAvançado
atelier-fashion

ADLC Toolkit

atelier-fashion/adlc-toolkit

Fluxo SDLC completo e orquestração de sprints para desenvolvimento spec-driven com Claude

Ver no GitHub
BomPluginScore · de 0 a 100

Conjunto de skills, agentes e templates para desenvolvimento orientado por especificação com Claude Code. Oferece um fluxo completo de SDLC (requisitos → arquitetura → implementação → review → deployment) com orquestração de pipelines paralelos, validação em múltiplas fases e auditoria de saúde de codebase.

Instalação

$npx convez-ai atelier-fashion/adlc-toolkit

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
174
Forks
43
Acompanhando
3
Saúde
50%
Último commit
há 2 dias
Versão
v5.4.0
Issues abertas
2
Contribuidores
2

Casos de uso

  • Estruturar requisitos e arquitetura antes de implementar
  • Orquestrar múltiplas features em paralelo com merge-gates determinísticos
  • Executar review multi-agente (correção, qualidade, segurança, testes)
  • Automatizar canary deployments com smoke tests
  • Auditar saúde de codebase e otimizar custos de API

Veredito

Toolkit maduro e bem-estruturado para times que querem sistemática rigorosa em spec-driven development. Exige comprometimento com a metodologia ADLC, mas entrega governança forte em pipelines complexos com múltiplas features em voo.

README

A tradução para o português deste README ainda está na fila.

ADLC Toolkit

Skills, agents, and templates for spec-driven development with Claude Code. Stack-agnostic at the core, with optional preset configs for common stacks (iOS+Firebase+Cloud Run, etc.).

What's Included

Skills

SkillDescription
/initBootstrap .adlc/ structure in a new repo
/specWrite requirement specs from feature requests
/architectDesign architecture and break requirements into tasks
/validateValidate any ADLC phase output before advancing
/proceedEnd-to-end pipeline: validate → architect → implement → reflect → review → PR → wrapup. Opens a draft PR early and trial-merge-gates the merge to enforce ordering (REQ-483)
/sprintParallel pipeline orchestrator — launch multiple /proceed sessions across REQs. Has a workflow engine (--workflow, the deterministic adlc-sprint Dynamic Workflows script that restores per-REQ fan-out while keeping cross-REQ concurrency) with the legacy background-runner engine as an always-available fallback
/reflectPost-implementation self-review before formal review
/reviewMulti-agent code review (correctness, quality, architecture, tests, security)
/canaryCanary deployment with smoke tests — deploy zero-traffic revision and promote on success
/wrapupClose out a feature — commit, merge, deploy, update artifacts
/bugfixStreamlined bug fix workflow
/statusShow current state of all ADLC work
/manifestRemote-derived view of all in-flight ADLC work — open PRs + pushed feat/REQ-* branches, with advisory component/domain + file-footprint overlap and a deterministic merge order (REQ-483)
/analyzeCodebase health audit
/optimizeAPI cost & performance scanner
/template-driftDetect drift between a project's local .adlc/templates/ and the canonical toolkit templates

Templates

  • requirement-template.md — Requirement spec template
  • task-template.md — Technical task template
  • bug-template.md — Bug report template
  • assumption-template.md — Validated-assumption knowledge entry
  • lesson-template.md — Lesson-learned knowledge entry

Presets

Stack-shaped starter configs that seed .adlc/config.yml for common stacks. See presets/ for the current list.

Workflows

Deterministic Dynamic-Workflow scripts + the JSON-Schema literals they validate agent output against. See workflows/ — reached via the skills symlink and vendored into a consumer's .adlc/workflows/ by /init (same two-level path resolution as templates/ and partials/).

Tools

Standalone command-line utilities (not skills, installed via their own install.sh). See tools/kimi/ — Kimi K2.5 delegation CLIs (ask-kimi, kimi-write, extract-chat) for offloading token-heavy I/O from Claude Code sessions.

How it works

The toolkit is split into two layers:

  1. The toolkit repo (this repo) — generic skills, agents, and templates that work for any stack. Symlinked into ~/.claude/skills/ so every Claude Code session sees them.
  2. Per-project .adlc/ directory — lives in each code repo. Holds the project's specs, architecture, conventions, and a config.yml that declares the project's stack, deploy targets, and repo layout. All project-specific values live here, never in the toolkit.

Skills read .adlc/config.yml at runtime to resolve project-specific things (GCP project IDs, iOS device names, Cloud Run service names, etc.) — nothing is hardcoded in the skills themselves.

Setup

The toolkit uses a symlink-based live install: one canonical git clone on disk, exposed to Claude Code at ~/.claude/skills/ via an absolute-path symlink. There is no separate "installed" copy and no sync step — edits you commit to the clone are instantly visible to every Claude Code session on the machine.

1. Clone this repo

Pick any directory you keep code in. The toolkit doesn't care where it lives, as long as the symlink in step 2 uses an absolute path.

cd ~/code  # or wherever you keep repos — anywhere works
# Replace <owner> with the canonical upstream's GitHub owner (or your fork's)
git clone https://github.com/<owner>/adlc-toolkit.git

2. Symlink to Claude Code's skills and agents directories

# Back up any existing directories (rename is safe and reversible)
[ -e ~/.claude/skills ] && mv ~/.claude/skills ~/.claude/skills.bak
[ -e ~/.claude/agents ] && mv ~/.claude/agents ~/.claude/agents.bak

# Create symlinks — use ABSOLUTE paths so they resolve from any cwd.
# Replace the source path with wherever you cloned the toolkit.
TOOLKIT="$PWD/adlc-toolkit"
ln -s "$TOOLKIT" "$HOME/.claude/skills"
ln -s "$TOOLKIT/agents" "$HOME/.claude/agents"

Verify:

readlink ~/.claude/skills   # → absolute path to your adlc-toolkit clone
readlink ~/.claude/agents   # → absolute path to .../adlc-toolkit/agents
ls ~/.claude/skills/review/SKILL.md  # should resolve through the symlink

Git commands run from inside ~/.claude/skills/ transparently operate on the clone's .git directory, so you can use either path interchangeably.

3. Initialize a project

In any code repo:

claude
> /init

This bootstraps the .adlc/ directory with project-specific context, specs, and copies of the templates.

4. Configure for your stack

Pick a preset that matches your stack and copy it to .adlc/config.yml:

ls ~/.claude/skills/presets/
cp ~/.claude/skills/presets/ios-firebase-cloudrun.yml .adlc/config.yml
$EDITOR .adlc/config.yml  # replace every <placeholder> with a real value

If no preset matches, copy the bare template instead and fill it out from scratch:

cp ~/.claude/skills/templates/config-template.yml .adlc/config.yml

Single-repo projects without a backend can leave the file absent — every skill falls back to legacy single-repo behavior in that case.

Workflow

/spec → /validate → /architect → /validate → implement → /reflect → /review → merge → /wrapup

For bugs: /bugfix (report → analyze → fix → verify → ship)

For multi-REQ batches: /sprint (parallel /proceed runners)

Project Structure

After /init, each code repo will have:

.adlc/
  config.yml         # Project's stack, deploy config, and (optional) sibling repo layout
  context/           # Project-specific architecture, conventions, overview
  specs/             # Requirement docs, architecture docs, tasks
  knowledge/         # Assumptions validated, lessons learned
  templates/         # Copies of templates (from this toolkit)
  workflows/         # Copies of Dynamic Workflow scripts + schemas (from this toolkit)

The toolkit repo contains the process (skills + templates). Each code repo contains the artifacts (specs, architecture, knowledge).

Cross-Repo REQs

Some features span multiple repos (e.g., a feature that touches a backend API, a web frontend, and a mobile app at the same time). The toolkit supports these via the optional repos: block in .adlc/config.yml.

Key concept: "primary" is per-REQ

There is no fixed "primary repo." Whichever repo you invoke /proceed (or /bugfix) from becomes the primary for that REQ — it holds the spec, tasks, and pipeline-state.json for that work. A different REQ that originates in a sibling repo makes that sibling the primary. Every repo that may originate REQs gets its own .adlc/ structure and its own config.yml; the configs are mirror images of each other (each repo marks itself primary: true and lists the others as siblings).

config.yml shape

repos:
  api:
    primary: true       # only in this repo's config
  infrastructure:
    path: ../infrastructure
  app:
    path: ../app
  web:
    path: ../web

merge_order:            # default Phase 8 merge sequence
  - infrastructure
  - api
  - app
  - web

services:               # consumed by /canary, keyed by repo id
  api:
    cloud_run_service: api
    region: us-central1
    image_path: us-central1-docker.pkg.dev/<gcp-project>/api/api
  # (infrastructure has no service entry — it deploys via Terraform)

See templates/config-template.yml for the full annotated template (including project:, stack:, gcp:, and ios: sections).

What changes when cross-repo is configured

  • /proceed creates a worktree in every touched sibling, routes tasks by repo: frontmatter, opens one PR per repo, and merges in merge_order
  • /architect requires a repo: field on every task it generates
  • /validate checks that repo: values resolve to configured repo ids and that task files stay in their declared repo
  • /wrapup walks mergeOrder to land PRs in order and cleans up worktrees across every touched repo
  • /canary resolves service metadata from services: instead of a hardcoded table
  • /status reports cross-repo activity (REQs originating elsewhere that touch this repo)
  • /sprint delegates cross-repo mechanics to each /proceed; one sprint still originates all REQs from the invoking repo
  • /bugfix supports cross-repo bugs via repo: or touched_repos: on the bug frontmatter

Single-repo mode (default)

If no config.yml exists or it has only a single repos: entry, every skill falls back to legacy single-repo behavior. Existing projects are unaffected until they opt in by creating config.yml.

Stack support

The toolkit's workflow is stack-agnostic. Skills that need to do stack-specific things (deploy a Cloud Run service, push a build to an iOS device, etc.) read .adlc/config.yml to learn what your stack is and what concrete values to use.

CapabilityWhere the skill checksWhat you fill in
Deploy confirmation (/bugfix, /wrapup)stack.backends includes cloud-rungcp.staging_project, gcp.production_project
Canary deploys (/canary)services: blockservice name, region, image path per repo
iOS device deploys (/bugfix, /wrapup)stack.frontends includes iosios.deploy_targets, ios.deploy_command
Convention checking (/review, /reflect).adlc/context/conventions.mddeclare your project's naming, logging, and API conventions

If you want to add support for a new stack (e.g., AWS Lambda backends, Android device deploys), edit the relevant skill to handle the new stack.* value and document it in templates/config-template.yml. PRs welcome.

Updating

Pull the latest toolkit to update all skills across all projects:

cd "$(readlink ~/.claude/skills)"
git pull

Since ~/.claude/skills is a symlink, changes are picked up immediately.

Contributing

This is published as a generic toolkit you can fork or contribute back to. Patches that add presets, support new stacks, or sharpen workflows for stacks already supported are all welcome.

Ver o original no GitHub

Bom para

Relacionados