Assembly Instructions: Digital Talent

Assembly Instructions: Digital Talent

Author: Pablo (Production Line Architect) Version: 1.0 Date: 2026-03-18 Purpose: Step-by-step recipe for building any digital talent product

Prerequisites

  1. Completed solution specification (from Stage 2)
  2. Completed pattern selection (from Stage 3)
  3. Client domain documentation (methodology, frameworks, references)
  4. Client tool documentation (if integrating with existing tools)
  5. Client naming conventions
  6. Work order with product-specific configuration

Assembly Overview

Phase A: Repository Setup           (30 min)
Phase B: Core Agent Configuration   (2-4 hours)
Phase C: Skill Assembly             (variable -- depends on product complexity)
Phase D: Template Library           (variable -- depends on output types)
Phase E: Reference Materials        (1-2 hours)
Phase F: Orchestration & Workflow   (0-3 hours -- some products don't need orchestration)
Phase G: Documentation              (2-3 hours)
Phase H: Verification               (1-2 hours)

Phase A: Repository Setup

Create the client repository structure:

{client-repo}/
+-- .claude/commands/templates/
+-- content-in/{domain}/
+-- content-in/tools/
+-- memory/
+-- workflows/                    (if orchestration needed)
+-- CLAUDE.md
+-- README.md
+-- .gitignore

Adjust subdirectories under content-in/ based on the product domain (e.g., content-in/methodology/ for EA, content-in/policies/ for compliance).

A.2 Create Request Folder Structure

If the work order defines a per-request working directory structure (e.g., demandes-ae/DAE-NNNN/), create the folder template and document the convention in CLAUDE.md.

Initialize git. Configure .claude/settings.json for permissions that ship with the product (allow reads, confirm writes, deny destructive ops). Use .claude/settings.local.json for developer-only settings during build (this file should not ship to client).

Phase B: Core Agent Configuration

B1. Write CLAUDE.md

Required sections (adapt headings to product domain):

  1. Role definition -- "You are a {product type} agent for {client}."
  2. Workspace rules -- File conventions, safety rules, working language
  3. Structure -- Directory layout
  4. Skills table -- All commands with: name, usage, input, output, model recommendation
  5. Workflow -- Standard workflow pipeline for this product (if applicable)
  6. Conventions -- Naming patterns for files, outputs, requests, decisions
  7. Model selection -- Cost optimization matrix per work order config
  8. Permissions -- Autonomous vs. confirm vs. deny
  9. Known issues -- Caveats and workarounds

B2. Write README.md (client-facing overview)

B3. Create workspace file (if VS Code)

Phase C: Skill Assembly

Build all skills listed in the solution specification. The skill set is defined by the work order -- it varies entirely by product type.

Skill Assembly Process (for each skill)

  1. Start from reference -- Use the reference implementation listed in the work order (if available)
  2. Extract the pattern -- Identify the reusable structure (input spec, processing logic, output format)
  3. Adapt for client -- Replace domain references, adjust naming conventions, translate if needed, adjust tool integration, update output format
  4. Add quality checks -- Input validation, output verification, error handling
  5. Set model recommendation -- Based on task complexity and cost optimization
  6. Write to .claude/commands/{skill-name}.md

Skill Requirements

Each skill must contain:

  • Frontmatter (name, description, usage)
  • Input specification with path resolution rules
  • Numbered processing steps
  • Output specification (file name pattern, format, destination)
  • Quality checks
  • Model recommendation

Scope Creep Handling

If additional skills emerge during assembly beyond those specified in the solution spec, document them in the assembly checklist and update the work order. Do not add undocumented skills.

Phase D: Template Library

Build output templates as defined in the work order. Template types vary by product:

Product Domain Typical Templates
Enterprise Architecture Draw.io diagrams (various TOGAF levels), document templates
Data Governance Data catalog schemas, lineage diagrams, quality report templates
Compliance Audit checklists, gap analysis templates, evidence collection forms
Project Management Status report templates, risk matrices, stakeholder maps

Place templates in .claude/commands/templates/. Each template must be valid for its format, use client-appropriate styling, and include placeholder elements.

Phase E: Reference Materials

Load domain-specific reference materials into content-in/:

  • Domain framework documentation -- Summary of client methodology, terminology glossary, process lifecycle
  • Tool documentation -- Data model, validation rules, field definitions (if tool integration)
  • Quality criteria -- Verification checklists, quality standards, formatting guides

Common Domain-to-Subdirectory Mappings

Domain Typical content-in/ Subdirectories
EA methodology/, meta-model/, tools/, requests/
Data Governance policies/, schemas/, lineage/, glossary/
Compliance regulations/, checklists/, evidence/, controls/
Project Management templates/, metrics/, standards/

Format Guidance

Prefer markdown (.md) for all reference materials -- agents read markdown natively. For binary files (.pdf, .jpg, .doc), provide a markdown summary alongside the original. Binary files may not be directly readable by the agent.

Phase F: Orchestration and Workflow

Not all products need orchestration. Simple products with independent skills may skip Phase F entirely.

For products with multi-step workflows:

F1. Orchestrator Skill

A central skill that:

  1. Detects current state of a work request (scans for expected output files)
  2. Plans remaining steps (follows the product workflow)
  3. Executes each step by invoking the appropriate skill
  4. Tracks progress
  5. Enforces mandatory halt points (human approval checkpoints)

F2. Workflow Documentation

Document the standard pipeline for this product: execution order, quality gates, file flow between steps.

F3. CI/CD Pipeline (optional)

Automated validation (linting, format checks, frontmatter validation) if the client uses CI/CD.

Phase G: Documentation

Remy (Technical Documentation Engineer) assists with:

  • User Guide -- What the agent does, how to start requests, how to use each skill, interpreting outputs, troubleshooting
  • Configuration Guide -- Updating references, adjusting conventions, modifying skills, managing templates, cost management
  • Skill Reference Card -- Quick-reference table: all skills with name, usage, input, output, model
  • Quick-Start Cheat Sheet -- One-page guide covering: install/setup, first request walkthrough, top 3 skills with example usage

G.5 Flow Diagram (how the talent works)

Every delivered talent ships with a visual "how it works" diagram -- the first thing the client sees to understand the talent at a glance.

  1. Copy production-lines/digital-talent/templates/diagram-template.yaml to the talent repo root as diagram.yaml.
  2. Fill it from the talent's skills table (CLAUDE.md) and its §Workflow section: triggers, commands, tools, collaborators, outputs.
  3. Run /toolkit:agent-diagram <path-to-diagram.yaml> to generate docs/how-it-works.html (n8n-style interactive flow) + docs/how-it-works.md.
  4. Ensure the talent's hub index.html has a <!-- DIAGRAM --> marker so the diagram link is injected automatically.

Regenerate whenever the talent's skills change.

Phase H: Verification

H1. Structural Verification

All expected files exist: CLAUDE.md, README.md, all skills from the solution spec, all templates, reference materials, workflow docs (if applicable).

H2. Skill Smoke Tests

For each skill: provide sample input, execute, verify output format and naming, verify domain terms and language.

H3. End-to-End Test (if orchestrator exists)

Create test request. Provide sample input. Run orchestrator. Verify each step produces output. Verify halt points work. Resume after approval. Verify final outputs.

H4. CLAUDE.md Consistency Check

Skills table matches actual .claude/commands/ files. File paths correct. Naming conventions consistent. Model recommendations match.

H5. CLAUDE.md-to-Commands Consistency Check

Compare the skills table in CLAUDE.md against actual files in .claude/commands/. Verify: every listed skill has a corresponding file, every file has a table entry, no phantom references. Document any discrepancies.

H6. Strip Dev-Only Artifacts

Remove or exclude any development-only files before handoff to QA. This includes: .claude/skills/ dev tools (skill-creator, improve-agent, etc.), internal notes, TODO files, architecture analysis documents. These are build artifacts, not product deliverables.

Final Assembly Checklist

Complete the assembly checklist using the template at templates/assembly-checklist-template.md. Copy the template into the order directory and fill in all fields including file counts, skill counts, and verification results.

Post-Assembly

Submit to Quinn (QA) for Stage 5 testing. Do not deploy without QA PASS certification.

Handoff includes: complete build artifacts, completed assembly checklist, known limitations, test data from Phase H.