From Galaxy Variant Exercise:

1. Signature headline stays — "Building at the edge of trust" is the brand
2. companyAccent is REQUIRED — Add inline company name (— with {Company})
3. Existing connections are gold — Lead with what you've already proven
4. Stats must be verifiable — Every metric traced to knowledge base
5. Pause between phases — Get user approval before proceeding

Phase 1: JD Analysis & Must-Have Extraction

Goal: Extract NON-GENERIC requirements using the deterministic analyze:jd script.

Step 1.1: Save JD to File

If user provides JD text, save it first:

# Save JD to source-data/jd-{company}.txt
echo "[JD TEXT]" > source-data/jd-{company}.txt

Step 1.2: Run Deterministic JD Analysis

USE THE SCRIPT — it automatically filters 47+ generic phrases and extracts specific requirements:

npm run analyze:jd -- --file source-data/jd-{company}.txt --save

This outputs to capstone/develop/jd-analysis/{slug}.yaml with:

• extracted.company, extracted.role, extracted.yearsRequired
• mustHaves[] with category and specificity (high/medium/low)
• niceToHaves[]
• ignoredGeneric[] — what was filtered out
• domainKeywords[] — crypto, fintech, developer_tools, etc.
• searchTerms[] — ready for knowledge base search

What the script filters automatically:

• "Team player", "excellent communicator", "fast-paced environment"
• "Passionate about [X]", "self-starter", "attention to detail"
• "Proven track record", "data-driven", "results-oriented"
• 40+ more generic phrases (see scripts/analyze-jd.ts:GENERIC_PHRASES)

Step 1.3: Review Analysis Output

# Read the generated analysis
cat capstone/develop/jd-analysis/{slug}.yaml

Check for:

• Correct company/role extraction
• Meaningful must-haves (not generic)
• Appropriate domain keywords

Step 1.4: Check for Existing Variants

ls content/variants/ | grep -i {company}

Output: JD analysis summary to user for confirmation before proceeding.

Phase 1.5: Alignment Gate (GO/NO-GO)

Goal: Score alignment BEFORE investing time in content generation using the search:evidence script.

Run Evidence Search

USE THE SCRIPT — it searches the knowledge base and generates an alignment report:

npm run search:evidence -- --jd-analysis capstone/develop/jd-analysis/{slug}.yaml --save

This outputs to capstone/develop/alignment/{slug}.yaml with:

• summary.alignmentScore — 0.0 to 1.0
• summary.recommendation — PROCEED | REVIEW | SKIP
• summary.strongMatches — count of high-relevance matches (≥70%)
• summary.moderateMatches — count of medium-relevance matches (40-70%)
• matches[] — sorted by relevance with evidence snippets
• gaps[] — search terms with no matches

Alternative: Manual Search Terms

If you have specific terms not from JD analysis:

npm run search:evidence -- --terms "crypto,staking,infrastructure,api" --threshold 0.5 --save

Review Alignment Report

cat capstone/develop/alignment/{slug}.yaml

Decision Framework

Honesty Check

For REVIEW/SKIP cases, the script surfaces:

• gaps[] — terms with no matching evidence
• Low relevance matches that may be stretches

Surface honestly:

• Which must-haves have no evidence
• Whether gaps are addressable (transferable skills) or hard blockers
• Honest assessment: "This role requires X, which isn't in your background"

PAUSE: Show alignment score and recommendation. Get explicit GO/NO-GO from user.

Phase 2: Knowledge Base Query

Goal: Find matching achievements and stories.

1. Search achievements:

   ls content/knowledge/achievements/
   

2. Read relevant achievement files matching JD requirements

3. Look for existing client relationships:

   • Search for company name in achievements/stories
   • Example: Galaxy was already an Anchorage client (ETH staking)

4. Rank matches by relevance (0.0-1.0):

   • Direct skill match: 0.9-1.0
   • Related experience: 0.7-0.9
   • Transferable skills: 0.5-0.7

Output: List of relevant achievements with relevance scores.

Phase 2.5: Bullet Coverage Check

Goal: Ensure experience highlights cover all 7 PM competency bundles using the check:coverage script.

Run Coverage Check

USE THE SCRIPT — it automatically categorizes bullets into the 7 PM competency bundles:

npm run check:coverage

For JSON output (easier to process):

npm run check:coverage -- --json

To save report:

npm run check:coverage -- --save

The 7 Competency Bundles (Automated)

The script categorizes based on keywords (see scripts/check-coverage.ts:BUNDLES):

Review Coverage Output

The script outputs:

• Count per bundle
• Examples of bullets in each bundle
• gaps[] — bundles with <2 bullets
• overweight[] — bundles with 5+ bullets
• Overall balance assessment

Interpretation

Using Coverage for This Variant

Cross-reference gaps with JD must-haves:

1. Does this role care about the gap? (Check Phase 1 analysis)
2. Can the bio/tagline emphasize this competency?
3. Are there achievements in knowledge base that weren't surfaced?

Note: Not all variants need all 7 bundles. A technical PM role may not care about "Business & Marketing." Use the JD must-haves to determine which gaps matter.

Phase 3: Content Generation

IMPORTANT: Invoke dmitrii-writing-style skill before writing bio content.

Hero Section

hero:
  status: "Open to Product Roles"  # Keep simple
  headline:
    - text: "Building"
      style: "italic"
    - text: "at the edge of"
      style: "muted"
    - text: "trust"
      style: "accent"
  companyAccent:  # REQUIRED
    - text: "with"
      style: "muted"
    - text: "{Company}"
      style: "accent"
  subheadline: >
    [Tailored elevator pitch mentioning company connection]

About Section

about:
  tagline: >
    [One-line positioning statement]
  bio:
    - >
      [Paragraph 1: Recent experience, relevant achievements, company connection]
    - >
      [Paragraph 2: Career arc leading to this opportunity + vision]
  stats:
    - value: "[X]+"
      label: "[Relevant metric]"
    - value: "[Y]"
      label: "[Relevant metric]"
    - value: "[Z]"
      label: "[Relevant metric]"

Relevance Scoring

relevance:
  caseStudies:
    - slug: "[most-relevant]"
      relevanceScore: 1.0
      reasoning: "[Why this matches JD]"
    # ... ranked list
  skills:
    - category: "[Top category]"
      relevanceScore: 1.0
    # ... ranked list

PAUSE: Show generated content to user for review before proceeding.

Phase 4: Variant File Creation

1. Create variant YAML:

   # Write to content/variants/{slug}.yaml
   

2. Sync to JSON:

   npm run variants:sync -- --slug {slug}
   

3. Verify JSON created:

   ls content/variants/{slug}.json
   

Phase 5: Evaluation Pipeline

1. Run evaluation:

   npm run eval:variant -- --slug {slug}
   

2. Review extracted claims (metrics with anchors)

3. For each unverified claim, verify against knowledge base:

   npm run eval:variant -- --slug {slug} --verify {claim-id}={source-path}
   

4. Target: 100% claims verified

PAUSE: Show claims status to user before proceeding.

Phase 6: Red Team Pipeline

1. Run red team scan:

   npm run redteam:variant -- --slug {slug}
   

2. Review findings:

   • FAIL — Must fix before publishing
   • WARN — Review and decide

3. Common issues and fixes:

   Check	Issue	Fix
   RT-ACC-CLAIMS	Unverified claims	Run Phase 5 verification
   RT-SEC-SECRETS	Tokens in content	Remove sensitive data
   RT-TONE-SYCOPHANCY	Flattery detected	Rewrite objectively
   RT-PRIV-JD	Long JD exposed	Truncate in YAML

PAUSE: Show redteam results to user for approval.

Phase 7: Final Review

1. Start dev server if not running:

   npm run dev
   

2. Open variant in browser:

   http://localhost:5173/{company}/{role}
   

3. Visual checklist:

   • companyAccent renders inline after "trust"
   • Stats are visible and accurate
   • Bio reads naturally
   • Case studies are relevant

4. Offer to commit if approved.

Phase 8: Resume Generation

Goal: Generate a variant-specific resume PDF and link it to the variant.

1. Generate variant resume:

   npm run generate:resume -- --variant {slug}
   

   This will:

   • Render the resume at /{company}/{role}/resume
   • Output PDF to public/resumes/{slug}.pdf
   • Auto-update variant YAML with resumePath: /resumes/{slug}.pdf

2. Sync the updated variant:

   npm run variants:sync -- --slug {slug}
   

3. Verify resume was generated:

   ls -la public/resumes/{slug}.pdf
   

Note: The variant resume uses the merged profile/experience data, so it reflects the tailored content (bio, stats, tagline) specific to this role.

Quality Checklist

Before marking variant complete:

• All claims verified against knowledge base
• No hallucinated achievements
• Company connection established (existing client? industry overlap?)
• Signature headline preserved with companyAccent (REQUIRED)
• Stats are verifiable and impactful
• Red team passes (0 FAIL, minimal WARN)
• Would defend every claim in an interview
• Writing style matches dmitrii-writing-style
• Resume PDF generated and linked (resumePath in variant metadata)

File Locations Reference

Commands Reference

# ═══════════════════════════════════════════════════════════════
# PHASE 1: JD Analysis (deterministic)
# ═══════════════════════════════════════════════════════════════
npm run analyze:jd -- --file source-data/jd-{company}.txt --save
npm run analyze:jd -- --file jd.txt --json  # JSON output

# ═══════════════════════════════════════════════════════════════
# PHASE 1.5: Evidence Search (deterministic)
# ═══════════════════════════════════════════════════════════════
npm run search:evidence -- --jd-analysis capstone/develop/jd-analysis/{slug}.yaml --save
npm run search:evidence -- --terms "crypto,staking,api" --threshold 0.5

# ═══════════════════════════════════════════════════════════════
# PHASE 2.5: Coverage Check (deterministic)
# ═══════════════════════════════════════════════════════════════
npm run check:coverage
npm run check:coverage -- --json
npm run check:coverage -- --save

# ═══════════════════════════════════════════════════════════════
# PHASE 4-6: Variant Pipeline
# ═══════════════════════════════════════════════════════════════
npm run variants:sync -- --slug {slug}
npm run eval:variant -- --slug {slug}
npm run eval:variant -- --slug {slug} --verify {id}={path}
npm run redteam:variant -- --slug {slug}

# ═══════════════════════════════════════════════════════════════
# PHASE 8: Resume Generation
# ═══════════════════════════════════════════════════════════════
npm run generate:resume -- --variant {slug}
npm run variants:sync -- --slug {slug}  # Sync after resume path update

# ═══════════════════════════════════════════════════════════════
# PREVIEW
# ═══════════════════════════════════════════════════════════════
npm run dev
open "http://localhost:5173/{company}/{role}"
open "http://localhost:5173/{company}/{role}/resume"  # Preview resume page

Example: Galaxy PM Variant

Job: Director, Technical Program Manager at Galaxy

Key Learnings Applied:

1. Found existing connection: Galaxy was already an Anchorage client (ETH staking)
2. Matched L2 integration framework to "cross-functional" TPM requirement
3. Used punchy stats: "8+", "7+", "Zero" (all verified)
4. companyAccent: trust — with Galaxy (inline, subtle)
5. Status: "Open to Product Roles" (simple, not desperate)

Result: All 6 claims verified, redteam passed, variant shipped.