# Full Engineering Pass

> Use for a customer engagement or major release that needs the whole engineering picture at once — composes all five domain modules (architecture, data, security, devops, testing) in dependency order. One invocation produces architecture decisions, a data model, a security posture, an ops plan, and quality validation together.

- Skill: `jokerman89/full-engineering-pass` (Agent Skill)
- Install (CLI): `npx skillmds@latest add jokerman89/full-engineering-pass`
- Raw SKILL.md: https://api.skillmd.com/api/skills/jokerman89/full-engineering-pass/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: jokerman89 (https://skillmd.com/u/jokerman89)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/jokerman89/full-engineering-pass

---


You are the FULL-ENGINEERING-PASS — the composition that runs all 5 engineering-domain modules in DAG order.

## What this skill does

Orchestrates TA → DA‖SC → DH → TQ as a single end-to-end engineering pass. Produces the complete artifact set for a customer engagement or major release in one invocation.

```
Stage 1: TA (tech-architecture)
  ↓ produces: system-arch + ADRs + contracts + dependency graph + NFRs
  ↓
Stage 2: DA  +  SC   (run in parallel — independent concerns)
  ↓ DA produces: data-model + schema + migration + retention + query patterns
  ↓ SC produces: threat-model + secrets + auth + compliance + audit-path + runbook
  ↓
Stage 3: DH (devops-hosting)
  ↓ reads: TA scaling-plan, DA migration-plan, SC threat-model + audit-path
  ↓ produces: deployment + observability + SLI/SLO + cost + rollback + on-call
  ↓
Stage 4: TQ (testing-qa)
  ↓ reads: everything above
  ↓ produces: coverage + perf-budget + contract-tests + regression + chaos
  ↓
SHIP gate: aggregate 30-dim score (6 dims × 5 modules); ≥80 per module to ship
```

Each module has its own 5 checkpoints + 6-dim rubric. The composition is the **orchestration + ordering + cross-module brief handoffs + aggregate scoring**.

## When to use

- Customer engagement requiring complete engineering evidence (architecture review, audit prep, customer audit)
- New service approaching production
- Major release prep
- Annual engineering health review
- SENSE auto-recommends when customer-engagement-deep mode detected + scope is substantial

## When NOT to use

- Hotfix (use `/li:cycle --mode hotfix`)
- Single-module work (invoke the module directly: `/li:ta full`, `/li:da full`, etc.)
- Pre-feature exploration (use `/li:cycle --mode research-dive`)
- Routine work (the cap is 500k soft / 750k hard — overkill for small changes)

## Composition DAG

```yaml
stages:
  - stage: 1
    name: architecture
    modules: [ta]
    parallel: false
    why_first: "architecture decisions constrain everything downstream"

  - stage: 2
    name: data_and_security
    modules: [da, sc]
    parallel: true
    why_parallel: "data design + security posture are independent at this layer; both consume only TA's output"

  - stage: 3
    name: deployment
    modules: [dh]
    parallel: false
    depends_on: [ta, da, sc]
    why_after: "DH reads TA scaling-plan, DA migration-plan, SC threat-model + audit-path"

  - stage: 4
    name: validation
    modules: [tq]
    parallel: false
    depends_on: [ta, da, sc, dh]
    why_last: "TQ validates everything the prior 4 modules produced"
```

## Workflow

### Step 1 — Parse invocation + read pack policy

```bash
mode="${1:-full}"               # full | resume | dry-run
skip_modules="${SKIP_MODULES:-}" # CSV of module names to skip

source "${LINTEL_SOURCE_ROOT:-$LINTEL_REPO_ROOT}/lib/pack-resolver.sh"
voice=$(resolve_pack_field voice.default_tier)

# Activate customer-engagement-deep mode if pack defines it
deep_mode=$(resolve_pack_field navigation.customer_engagement_deep 2>/dev/null || echo false)
```

### Step 2 — Enumerate available modules + check graceful degradation

```bash
all_modules=(ta da sc dh tq)
available_modules=()
missing_modules=()

for module in "${all_modules[@]}"; do
  if [ -f "$LINTEL_REPO_ROOT/skills/$module/SKILL.md" ]; then
    available_modules+=("$module")
  else
    missing_modules+=("$module")
  fi
done

if [ "${#missing_modules[@]}" -gt 0 ]; then
  echo "⚠ MODULES NOT FOUND: ${missing_modules[*]}"
  echo "⚠ Composition will gracefully skip missing modules + audit the gap."
  echo "⚠ Operator: confirm to proceed with partial pass, or land missing modules first."
  # Wait for operator confirm unless --auto
fi
```

### Step 3 — Resolve skip-list + final module set

```bash
final_modules=()
for module in "${available_modules[@]}"; do
  case ",$skip_modules," in
    *",$module,"*)
      echo "Skipping $module (operator-requested via --skip-module)"
      ;;
    *)
      final_modules+=("$module")
      ;;
  esac
done

if [ "${#final_modules[@]}" -eq 0 ]; then
  echo "ERROR: no modules to run (all available skipped or missing)"
  exit 1
fi
```

### Step 4 — Dispatch by DAG stage

```bash
mkdir -p .claude/runtime/state/full-engineering-pass
state_file=".claude/runtime/state/full-engineering-pass/00-state.md"
# Unified audit writer → .claude/runtime/audit/full-engineering-pass.jsonl
source "${LINTEL_SOURCE_ROOT:-$(git rev-parse --show-toplevel)}/bin/_audit.sh"

declare -A module_score
declare -A module_status

# ─── Stage 1: TA ──────────────────────────────────────
if [[ " ${final_modules[*]} " =~ " ta " ]]; then
  echo "════ Stage 1: TA (tech-architecture) ════"
  /li:ta full || module_status[ta]="FAILED"
  module_score[ta]=$(read_module_score ta)
  forge_envelope phase_transition full-engineering-pass ta--complete brief .claude/runtime/state/ta/...
fi

# ─── Stage 2: DA + SC (parallel) ──────────────────────
echo "════ Stage 2: DA + SC (parallel) ════"
stage2_modules=()
[[ " ${final_modules[*]} " =~ " da " ]] && stage2_modules+=(da)
[[ " ${final_modules[*]} " =~ " sc " ]] && stage2_modules+=(sc)

for module in "${stage2_modules[@]}"; do
  # Phase 4 may upgrade to actual parallel execution via subagent fan-out;
  # v4.6 ships sequential-within-stage with parallel-eligible marker
  /li:"$module" full || module_status["$module"]="FAILED"
  module_score["$module"]=$(read_module_score "$module")
done

# ─── Stage 3: DH ──────────────────────────────────────
if [[ " ${final_modules[*]} " =~ " dh " ]]; then
  echo "════ Stage 3: DH (devops-hosting) ════"
  /li:dh full || module_status[dh]="FAILED"
  module_score[dh]=$(read_module_score dh)
fi

# ─── Stage 4: TQ ──────────────────────────────────────
if [[ " ${final_modules[*]} " =~ " tq " ]]; then
  echo "════ Stage 4: TQ (testing-qa) ════"
  /li:tq full || module_status[tq]="FAILED"
  module_score[tq]=$(read_module_score tq)
fi
```

### Step 5 — Aggregate 30-dim score (6 dims × 5 modules)

```bash
total_score=0
module_count=0

for module in "${final_modules[@]}"; do
  score="${module_score[$module]:-0}"
  total_score=$((total_score + score))
  module_count=$((module_count + 1))

  if [ "$score" -lt 80 ]; then
    echo "FAIL: $module score $score < 80"
  fi
done

aggregate_score=$((total_score / module_count))
```

### Step 6 — SHIP gate

```bash
ship_verdict="GREEN"
[ "$aggregate_score" -lt 80 ] && ship_verdict="YELLOW"

# Any module BLOCKED → composition BLOCKED regardless of aggregate
for module in "${final_modules[@]}"; do
  [ "${module_status[$module]:-}" = "FAILED" ] && ship_verdict="RED"
done

# Missing modules → DONE_WITH_CONCERNS
[ "${#missing_modules[@]}" -gt 0 ] && [ "$ship_verdict" = "GREEN" ] && ship_verdict="YELLOW"
```

### Step 7 — Audit + emit composition report

```bash
ts=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
out=".claude/runtime/state/full-engineering-pass/composition-report-$ts.md"
{
  echo "# Full engineering pass — $(date -u +%Y-%m-%dT%H:%M:%SZ)"
  echo "## Aggregate score: $aggregate_score / 100"
  echo "## SHIP verdict: $ship_verdict"
  echo ""
  echo "## Per-module scores"
  for module in "${final_modules[@]}"; do
    echo "- $module: ${module_score[$module]}/100 (${module_status[$module]:-DONE})"
  done
  if [ "${#missing_modules[@]}" -gt 0 ]; then
    echo ""
    echo "## Missing modules (skipped gracefully)"
    for module in "${missing_modules[@]}"; do
      echo "- $module (not present on this branch)"
    done
  fi
  echo ""
  echo "## Cross-module artifacts produced"
  echo "- .claude/runtime/state/ta/ (architecture decisions, ADRs, contracts, NFRs)"
  echo "- .claude/runtime/state/da/ (data model, migrations, retention)"
  echo "- .claude/runtime/state/sc/ (threat model, secrets, auth, compliance, audit)"
  echo "- .claude/runtime/state/dh/ (deployment, observability, SLO, cost, on-call)"
  echo "- .claude/runtime/state/tq/ (coverage, perf budget, contracts, regression, chaos)"
} > "$out"

# One line via the unified writer (ts/operator/cycle_id come from the envelope)
audit_log full-engineering-pass full_engineering_pass_complete "aggregate_score=$aggregate_score" \
  "modules_run=${#final_modules[@]}" "modules_missing=${#missing_modules[@]}" "verdict=$ship_verdict"

echo ""
echo "════════════════════════════════════════════════════"
echo "  Full engineering pass: $ship_verdict (aggregate $aggregate_score/100)"
echo "  Modules: ${final_modules[*]}"
echo "  Skipped (missing): ${missing_modules[*]:-none}"
echo "  Report: $out"
echo "════════════════════════════════════════════════════"
```

## Status protocol

- **DONE** — all available modules score ≥ 80; aggregate ≥ 80; SHIP verdict GREEN
- **DONE_WITH_CONCERNS** — aggregate ≥ 60 OR 1-2 modules in DONE_WITH_CONCERNS; SHIP verdict YELLOW
- **BLOCKED** — any module BLOCKED OR aggregate < 60; SHIP verdict RED
- **NEEDS_CONTEXT** — pack policy missing customer-engagement-deep mode for high-stakes engagements

## Pause-points

- Pre-Stage 2: if Stage 1 score < 80, surface dimension breakdown, ask to re-loop TA or accept
- Pre-Stage 3: if either DA or SC BLOCKED, surface gap, ask to refine or skip
- Pre-Stage 4: same as Stage 3
- Pre-SHIP: if aggregate < 80, surface module-level breakdown, ask to re-loop or accept-with-concern

## Hop-in support

YES via `--resume`:

```bash
/li:full-engineering-pass --resume
# reads .claude/runtime/state/full-engineering-pass/00-state.md
# continues from the stage where the prior run paused
```

## Integration

**Reads:**
- All 5 module SKILL.md files (or as-many as exist)
- `lib/pack-resolver.sh` for pack policy
- `~/.lintel/profile.yaml` `engineering.*` block (per-module preferences)

**Writes:**
- `.claude/runtime/state/full-engineering-pass/composition-report-<ts>.md`
- `.claude/runtime/state/full-engineering-pass/00-state.md` (for `--resume`)
- `.claude/runtime/audit/full-engineering-pass.jsonl`
- Brief Forge envelopes through the standard gate (one per stage transition)

**Triggered by:**
- Operator: `/li:full-engineering-pass`
- SENSE auto-recommendation when customer-engagement-deep mode + sufficient scope

## Graceful degradation

If 1-4 of the 5 modules are missing from the repo (partial-rollout state), the composition:
1. Surfaces the gap to operator before running
2. Asks confirmation to proceed
3. Runs the available modules in DAG order
4. Audits which modules were missing
5. SHIP verdict goes YELLOW even with full pass if modules were skipped (operator can override)

This handles the v4.x stacking-rollout window where SC + DH + TQ + composition land in stacked PRs.

## Anti-patterns

- **Running full-engineering-pass on a hotfix** — overkill; use `/li:cycle --mode hotfix`
- **Skipping TA** — every downstream module depends on architecture decisions
- **Running DA before TA** — DA reads TA's scaling-plan + boundary-review
- **Parallel-stage modules accessing each other's mid-flight state** — DA + SC must be independent within Stage 2
- **Treating aggregate score as the only signal** — per-module dimension breakdown is the actionable view
- **Hardcoding module list** — composition reads available modules from filesystem

## Voice tier behavior

`voice: internal`. Composition produces operator-facing engineering artifacts. Customer-facing voice picks up at the SHIP phase when the active pack adds voice alignment via Brief Forge (a company pack supplies this; none by default) — composition artifacts are inputs to that, not the customer-facing output.