Automates the architecture pipeline phases in dependency order from investigation to report.

Install

mkdir -p .claude/skills/pipeline-wfukatsu && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/16273" && unzip -o skill.zip -d .claude/skills/pipeline-wfukatsu && rm skill.zip

Installs to .claude/skills/pipeline-wfukatsu

Activation

This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.

Automated pipeline that executes all phases in dependency order. /architect:pipeline [target_path]. Supports --skip-*, --resume-from, --rerun-from, --lang flags.
161 charsno explicit “when” trigger
Intermediate

Key capabilities

  • →Execute architectural analysis phases in dependency order
  • →Generate consolidated HTML reports
  • →Handle product handoff detection for existing artifacts
  • →Manage context between phases for long pipelines
  • →Skip or resume execution from specific phases
  • →Support conditional execution of skills based on project conditions

How it works

The pipeline loads a dependency graph, initializes output directories, and executes each skill in order, verifying its output before proceeding. It records progress and accumulates findings between phases.

Inputs & outputs

You give it
A target project path and a skill-dependencies.yaml file
You get back
Reports under reports/ and a completed pipeline-progress.json

When to use pipeline

  • →Running automated architecture analysis
  • →Executing multi-phase design pipelines
  • →Generating system design reports

About this skill

Full Pipeline Execution

Shared files: a path written @rules/…, @skills/…, @templates/… or @docs/… is relative to the plugin root, ${CLAUDE_PLUGIN_ROOT} — not to the project being worked on. Read it from there.

Usage: /architect:pipeline [target_path] [--profile=full|enterprise|poc|analysis] [--depth=minimal|standard|comprehensive] [--no-learnings] [--skip-{phase}] [--resume-from=phase-N] [--rerun-from=phase-N] [--analyze-only] [--no-scalardb] [--lang=en|ja]

Expected Outcome

Complete the core architecture analysis and design pipeline for the target project: investigation through evaluation, redesign, target architecture, data/API design, the multi-perspective review, and the consolidated HTML report — as much of it as the run's profile and depth select (§ Profile and Depth). The final deliverables are the reports under reports/ produced by the phases in the dependency manifest.

Available Skills

The pipeline executes the phases defined in @skills/common/skill-dependencies.yaml in dependency order. Skills outside the manifest (infrastructure, security, observability, disaster recovery, implementation specs, test specs, code generation, cost estimation) are a manual extension tier: run them individually after the pipeline completes, or via /architect:start, which can sequence them interactively. They are intentionally not part of the automated run.

Execution Strategy

  1. Load the dependency graph from skill-dependencies.yaml, and with it the profiles and depths tables; resolve this run's profile and depth (§ Profile and Depth) and record them as options.profile and options.depth
  2. Initialize output directories with /architect:init-output
  3. Product handoff detection — glob the same set define-requirements ingests: reports/00_core/, reports/01_ux/, reports/02_spec/, reports/03_domain/, reports/04_quality/ and work/traceability.json. Keep the two sets identical — a run that stopped early (--profile=mvp writes only reports/00_core/) is still a handoff. Match files, not directories: /product:init-output creates reports/01_ux/domain-stories/ and reports/02_spec/ui-mocks/ empty, so a directory test passes on any initialized product project. If product artifacts exist, run define-requirements first with them as inputs (the product→architect handoff, @docs/design.md §1); it auto-detects and carries product IDs forward. Otherwise run the standard greenfield/legacy entry.
  4. Execute each phase as a sub-agent, never inline, and verify its output before proceeding to the next — see Phase Execution below for the call and for why
  5. Start the phases of a parallel_with group in one message, one sub-agent each, in the foreground and at most three phases at a time, and continue only when all of them have returned (see Phase Execution)
  6. Enable or disable conditional skills based on the conditions field: ScalarDB/data-layer from scalardb_enabled, and design-graphql directly from GraphQL/hybrid surfaces in canonical reports/03_design/api-style-decisions.json. Before that artifact exists, a legacy options.api_style_graphql is only a compatibility fallback. Invalid canonical JSON is a blocking error and must never be interpreted as REST-only.
  7. Phases the manifest marks optional: true may be skipped without failing the run; the ones marked evidence_gated: true follow the depth's optional_phases (§ Profile and Depth) — at none they are recorded skipped with summary depth <name> before anything is read. Three of them are dialogue-driven (create-domain-story, design-aggregate, design-state-machine) and an automated run has nobody to facilitate with: invoke those with --auto and record what that mode had to assume. analyze-ui and evaluate-ux run with --auto too, and evaluate-ux never with --base-url: an automated run evaluates the UI statically. When the inputs show no evidence for an optional phase — no domain to narrate, no invariant spanning more than one attribute (nothing to make an aggregate of), no aggregate with a lifecycle, no data model to analyze, no presentation layer (the technology stack reports none and no templates or routed views exist), no UI inventory to evaluate — record it skipped with the reason in summary rather than emitting a document derived from nothing. An optional phase that was skipped or never ran does not block its dependents: design-state-machine depends on design-aggregate for ordering, not for existence, and runs from redesign alone when there is no aggregate manifest (the dashboard applies the same rule).
  8. Record progress in work/pipeline-progress.json twice per phase: set status: "in_progress" with plugin: "architect" and started_at before invoking the skill (all of them at once for a parallel group), then completed / failed / skipped with completed_at, outputs and summary once it returns — never awaiting_approval or revising, which are the interactive orchestrator's: this run has nobody to ask, and a phase found awaiting_approval from an earlier interactive run is left as it is, not run and not skipped, and named in the final message for /architect:start to settle. Under Claude Code each stamp becomes a PHASE_* event in work/audit/events.jsonl through the token-usage hook (@skills/common/progress-registry.md § Audit Log) — do not append phase events yourself there. On a runtime without hooks (Codex, Omnigent) nothing observes the registry, so append the event yourself right after each stamp: python3 "${CLAUDE_PLUGIN_ROOT}/tools/lib/audit_log.py" <project_dir> PHASE_STARTED phase=<name> plugin=architect and PHASE_COMPLETED / PHASE_FAILED / PHASE_SKIPPED on return. The gate, question and verdict events are the phases' own on every runtime. The pre-write is the only signal that a phase is running while it runs — /architect:report-status renders it, and the token-usage hook attributes cost to whatever is in_progress, using plugin to keep the two pipelines' spend separable under the four phase names both manifests define. The product pipeline writes this same file, so never re-register or reset an entry that is not this manifest's — including under --rerun-from (@skills/common/progress-registry.md § One Registry, Two Pipelines)
  9. Accumulate findings in work/context.md between phases

Profile and Depth

Which phases a run executes is the manifest's profiles table; how much optional and review work it does is its depths table (@skills/common/skill-dependencies.yaml, after the phases). Resolve them before the first phase starts:

  • Profile. --profile=<name> when given; --analyze-only is --profile=analysis; a profile already in options.profile on a resumed run; otherwise full. A name the table does not define is an error naming the four it does — never a silent full. One exception: a profile naming a product profile (mvp, core-only, ux-to-spec) is the product run's record from before 0.60.1 (today it writes options.product_profile), not an architect choice — treat it as unset, resolve the architect profile as above and record it, leaving the product value readable as product_profile.
  • Depth. --depth=<name> when given, else the profile's depth. A --depth the table does not define is an error likewise.
  • Record both as options.profile and options.depth in work/pipeline-progress.json before init-output returns, so the dashboard and the token-usage hook read the same run you do.

Then the phase set is: the profile's phases, plus the evidence_gated optional phases the depth's optional_phases admits whose dependencies the profile runs (design-aggregate, design-state-machine and create-domain-story depend on redesign, so analysis never runs them at any depth; they are recorded skipped with summary outside profile analysis), plus — when review-synthesizer is in the profile — the depth's review_perspectives. define-requirements is listed by the profile and follows the path as before (the greenfield entry; on the legacy path only when documents were supplied), and the greenfield path drops the investigation and evaluation phases from whatever profile runs, as it always has. Every other core phase of the manifest is recorded skipped with summary outside profile <name> (or depth <name> for a perspective or an optional phase the depth dropped), at the moment it would otherwise have started, so the registry shows the run's shape and /architect:report-status files it as excluded rather than pending. Those skips belong to the profile that made them: a later run under a wider profile reads a skipped whose summary names an exclusion that no longer holds as pending again and runs the phase, and a run under a narrower profile shows a phase recorded in_progress / awaiting_approval / revising outside it as skipped, with a warning naming the stale stamp (the dashboard applies both rules, tools/lib/pipeline_status_data.py). A dependency that is outside the profile is satisfied for its dependents, like a conditional skipped one (§ Conditional Dependency Resolution) — the manifest guarantees every listed phase has its required dependencies in the same profile, so this only ever concerns optional phases and perspectives.

The depth's other two keys change how a phase runs, not whether:

  • optional_phases: evidence is step 7 as written; all runs each evidence-gated phase over every candidate it finds — pass no --domain / --context / --aggregate narrowing and tell the phase in its prompt to cover every bounded context, every context's aggregates and every aggregate with a lifecycle rather than the ones the evidence makes a case for.
  • `independent_reviewers:

Content truncated.

When not to use it

  • →When needing to run infrastructure, security, or observability skills
  • →When requiring implementation specs or code generation
  • →When cost estimation is the primary goal

Limitations

  • →Does not automatically include infrastructure, security, or observability skills
  • →Does not include implementation specs, test specs, or code generation skills
  • →Does not perform cost estimation

How it compares

This pipeline automates the execution of a predefined sequence of architectural analysis phases, unlike manually running each phase individually.

Compared to similar skills

pipeline side by side with the closest alternatives in the catalog.

SkillInstallsUpdatedSafetyDifficulty
pipeline (this skill)05moNo flagsIntermediate
value-stream-mapping010moNo flagsIntermediate
itil-expert07moNo flagsAdvanced
babysitter:assimilate08moNo flagsAdvanced

Try saying

Example prompts that trigger this skill in your AI assistant.

Search skills

Search the agent skills registry