pipeline
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.zipInstalls 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.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
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
- Load the dependency graph from
skill-dependencies.yaml, and with it theprofilesanddepthstables; resolve this run's profile and depth (§ Profile and Depth) and record them asoptions.profileandoptions.depth - Initialize output directories with
/architect:init-output - Product handoff detection — glob the same set
define-requirementsingests:reports/00_core/,reports/01_ux/,reports/02_spec/,reports/03_domain/,reports/04_quality/andwork/traceability.json. Keep the two sets identical — a run that stopped early (--profile=mvpwrites onlyreports/00_core/) is still a handoff. Match files, not directories:/product:init-outputcreatesreports/01_ux/domain-stories/andreports/02_spec/ui-mocks/empty, so a directory test passes on any initialized product project. If product artifacts exist, rundefine-requirementsfirst 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. - 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
- Start the phases of a
parallel_withgroup 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) - Enable or disable conditional skills based on the
conditionsfield: ScalarDB/data-layer fromscalardb_enabled, anddesign-graphqldirectly from GraphQL/hybrid surfaces in canonicalreports/03_design/api-style-decisions.json. Before that artifact exists, a legacyoptions.api_style_graphqlis only a compatibility fallback. Invalid canonical JSON is a blocking error and must never be interpreted as REST-only. - Phases the manifest marks
optional: truemay be skipped without failing the run; the ones markedevidence_gated: truefollow the depth'soptional_phases(§ Profile and Depth) — atnonethey are recordedskippedwith summarydepth <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--autoand record what that mode had to assume.analyze-uiandevaluate-uxrun with--autotoo, andevaluate-uxnever 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 itskippedwith the reason insummaryrather than emitting a document derived from nothing. An optional phase that was skipped or never ran does not block its dependents:design-state-machinedepends ondesign-aggregatefor ordering, not for existence, and runs fromredesignalone when there is no aggregate manifest (the dashboard applies the same rule). - Record progress in
work/pipeline-progress.jsontwice per phase: setstatus: "in_progress"withplugin: "architect"andstarted_atbefore invoking the skill (all of them at once for a parallel group), thencompleted/failed/skippedwithcompleted_at,outputsandsummaryonce it returns — neverawaiting_approvalorrevising, which are the interactive orchestrator's: this run has nobody to ask, and a phase foundawaiting_approvalfrom an earlier interactive run is left as it is, not run and not skipped, and named in the final message for/architect:startto settle. Under Claude Code each stamp becomes aPHASE_*event inwork/audit/events.jsonlthrough 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=architectandPHASE_COMPLETED/PHASE_FAILED/PHASE_SKIPPEDon 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-statusrenders it, and the token-usage hook attributes cost to whatever isin_progress, usingpluginto 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) - Accumulate findings in
work/context.mdbetween 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-onlyis--profile=analysis; a profile already inoptions.profileon a resumed run; otherwisefull. A name the table does not define is an error naming the four it does — never a silentfull. One exception: aprofilenaming a product profile (mvp,core-only,ux-to-spec) is the product run's record from before 0.60.1 (today it writesoptions.product_profile), not an architect choice — treat it as unset, resolve the architect profile as above and record it, leaving the product value readable asproduct_profile. - Depth.
--depth=<name>when given, else the profile'sdepth. A--depththe table does not define is an error likewise. - Record both as
options.profileandoptions.depthinwork/pipeline-progress.jsonbeforeinit-outputreturns, 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: evidenceis step 7 as written;allruns each evidence-gated phase over every candidate it finds — pass no--domain/--context/--aggregatenarrowing 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.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| pipeline (this skill) | 0 | 5mo | No flags | Intermediate |
| value-stream-mapping | 0 | 10mo | No flags | Intermediate |
| itil-expert | 0 | 7mo | No flags | Advanced |
| babysitter:assimilate | 0 | 8mo | No flags | Advanced |
Try saying
Example prompts that trigger this skill in your AI assistant.
You might also like
value-stream-mapping
Prorise-cool
Lean value stream mapping for identifying waste and optimization opportunities. Creates current/future state maps with cycle time analysis and improvement recommendations.
itil-expert
Anhvu1107
ALWAYS use this when the request matches Itil Expert: Expert advisor for ITIL 4 and ITIL 5 (2026 digital product paradigm), specialized in AI-native governance, sustainability, and value co-creation.
babysitter:assimilate
MaTriXy
Assimilate an external methodology, harness, or specification into babysitter process definitions.
openspec-onboard
studyzy
Guided onboarding for OpenSpec - walk through a complete workflow cycle with narration and real codebase work.
workflow-orchestration-patterns
wshobson
Design durable workflows with Temporal for distributed systems. Covers workflow vs activity separation, saga patterns, state management, and determinism constraints. Use when building long-running processes, distributed transactions, or microservice orchestration.
meta-automation-architect
comzine
Use when user wants to set up comprehensive automation for their project. Generates custom subagents, skills, commands, and hooks tailored to project needs. Creates a multi-agent system with robust communication protocol.