bootstrap
This skill should be used when the user says "bootstrap", "set up Jerry", "configure guardrails", "initialize Jerry", or asks how to get started with Jerry. Sets up Jerry's context distribution by syncing behavioral rules and patterns.
Best use case
bootstrap is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
This skill should be used when the user says "bootstrap", "set up Jerry", "configure guardrails", "initialize Jerry", or asks how to get started with Jerry. Sets up Jerry's context distribution by syncing behavioral rules and patterns.
Teams using bootstrap should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/bootstrap/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How bootstrap Compares
| Feature / Agent | bootstrap | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
This skill should be used when the user says "bootstrap", "set up Jerry", "configure guardrails", "initialize Jerry", or asks how to get started with Jerry. Sets up Jerry's context distribution by syncing behavioral rules and patterns.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Bootstrap Skill
> **Version:** 1.0.0
> **Framework:** Jerry Bootstrap
> **Constitutional Compliance:** Jerry Constitution v1.0
Let's get your bindings adjusted so you don't have any Jerry moments.
---
## Document Sections
| Section | Purpose |
|---------|---------|
| [Purpose](#purpose) | What this skill does |
| [When to Use This Skill](#when-to-use-this-skill) | Activation triggers |
| [What This Does](#what-this-does) | How context distribution works |
| [Quick Start](#quick-start) | Getting started commands |
| [How It Works](#how-it-works) | Architecture of the sync mechanism |
| [Options](#options) | CLI flags and arguments |
| [Troubleshooting](#troubleshooting) | Common issues and solutions |
| [For Contributors](#for-contributors) | Adding new rules and patterns |
| [Available Agents](#available-agents) | Agent registry for this skill |
| [Constitutional Compliance](#constitutional-compliance) | Principle mapping |
| [Integration with Other Skills](#integration-with-other-skills) | Cross-skill dependencies |
| [Templates](#templates) | Template usage |
| [Routing Disambiguation](#routing-disambiguation) | When this skill is the wrong choice |
| [References](#references) | Canonical sources |
---
## Document Audience (Triple-Lens)
This SKILL.md serves multiple audiences:
| Level | Audience | Sections to Focus On |
|-------|----------|---------------------|
| **L0 (ELI5)** | New users, contributors | [What This Does](#what-this-does), [Quick Start](#quick-start), [How It Works](#how-it-works) |
| **L1 (Engineer)** | Developers setting up Jerry | [Quick Start](#quick-start), [Options](#options), [Troubleshooting](#troubleshooting) |
| **L2 (Architect)** | Framework maintainers | [How It Works](#how-it-works), [For Contributors](#for-contributors), [Constitutional Compliance](#constitutional-compliance) |
---
## Purpose
The Bootstrap skill sets up Jerry's context distribution system by synchronizing behavioral rules and patterns from the canonical source (`.context/`) to Claude Code's read location (`.claude/`). This ensures that Claude Code always has access to the latest framework rules.
### Key Capabilities
- **Platform-Aware Linking** - Uses the best available strategy per platform (symlinks, junction points, or file copy)
- **Drift Detection** - Identifies when copied files are out of sync with the source
- **Idempotent Setup** - Safe to run multiple times; won't overwrite unless `--force` is used
- **Validation Mode** - Check existing setup without making changes (`--check`)
---
## When to Use This Skill
Activate when:
- First time setting up the Jerry repository
- After pulling updates that modify `.context/rules/` or `.context/patterns/`
- Troubleshooting Claude Code not seeing the latest rules
- Migrating Jerry to a new machine
- Verifying that context distribution is working correctly
---
## What This Does
Jerry's behavioral rules and patterns live in `.context/` (the canonical source). Claude Code reads them from `.claude/rules/` and `.claude/patterns/`. This skill syncs the two using platform-aware linking:
- **macOS/Linux**: Symlinks (instant, auto-propagating)
- **Windows with Developer Mode**: Symlinks
- **Windows without Developer Mode**: Junction points (no admin required)
- **Fallback**: File copy with drift detection
**Note on Guides:** The `.context/guides/` directory is intentionally NOT synced. Jerry uses a three-tier architecture where rules and patterns are auto-loaded at session start, but guides remain on-demand content. This prevents context bloat while keeping detailed guidance available when explicitly needed.
---
## Quick Start
Run the bootstrap script to set up context distribution:
```bash
# Full setup
uv run python scripts/bootstrap_context.py
# Check if you're already set up
uv run python scripts/bootstrap_context.py --check
# Force re-sync (overwrites existing)
uv run python scripts/bootstrap_context.py --force
```
---
## How It Works
```
.context/ .claude/
├── rules/ ──── symlink ────► ├── rules/
├── patterns/ ── symlink ────► ├── patterns/
└── templates/ ├── agents/ (stays)
├── commands/ (stays)
└── settings.json (stays)
```
The script (`scripts/bootstrap_context.py`) handles:
1. **Platform detection** - Picks the right linking strategy
2. **Existing setup check** - Won't overwrite unless `--force`
3. **Fallback chain** - Symlink -> junction point -> file copy
4. **Drift detection** - `--check` verifies sync integrity
---
## Options
| Flag | What It Does |
|------|-------------|
| (none) | Full bootstrap with friendly output |
| `--check` | Verify existing setup without changes |
| `--force` | Overwrite existing links/copies |
| `--quiet` | Minimal output (for CI/scripts) |
---
## Troubleshooting
**"Source not found"** - You're not in the Jerry repo root, or `.context/` is missing. Make sure you cloned the full repo.
**"Already linked"** - You're good! Run `--check` to verify, or `--force` to re-link.
**Windows junction point fails** - Try running from an elevated prompt, or ensure you're on the same drive as the repo.
**Drift detected** - Files in `.claude/rules/` don't match `.context/rules/`. This happens with file-copy setups. Run without `--check` to re-sync.
---
## For Contributors
If you add new rules to `.context/rules/` or patterns to `.context/patterns/`, they'll automatically appear in `.claude/` for anyone using symlinks/junctions. File-copy users need to re-run bootstrap.
### Adding New Rules
1. Create the rule file in `.context/rules/{rule-name}.md`
2. Follow the markdown navigation standards (H-23/H-24) - include navigation table
3. Use tier vocabulary (HARD/MEDIUM/SOFT) per `quality-enforcement.md`
4. Add an L2-REINJECT comment if the rule is critical
5. Test that symlink users see the new rule immediately
6. Document in release notes that file-copy users should re-bootstrap
---
## Available Agents
This skill does not use agent-based workflows. It provides a single bootstrap script that handles all setup operations.
**Invocation:** Run the bootstrap script directly via `uv run python scripts/bootstrap_context.py`
---
## Constitutional Compliance
The Bootstrap skill adheres to the **Jerry Constitution v1.0**:
| Principle | Requirement | Implementation |
|-----------|-------------|----------------|
| P-002: File Persistence | State persisted to filesystem | Symlinks/junctions or file copies created on disk |
| P-022: No Deception | Transparent about actions | Script reports exactly what it does (link/copy/skip) |
| H-05: UV Only | Use uv for Python execution | Script invoked via `uv run python` |
**Self-Critique Checklist (Before Response):**
- [ ] P-002: Are symlinks/copies persisted to disk?
- [ ] P-022: Does script output clearly state what happened?
- [ ] H-05: Did we use `uv run` instead of `python` directly?
---
## Integration with Other Skills
The bootstrap skill is foundational and does not integrate with other skills. However, it enables all other skills by ensuring that:
- `.context/rules/quality-enforcement.md` is accessible for adversarial quality mode
- `.context/rules/architecture-standards.md` is accessible for hexagonal architecture validation
- `.context/rules/coding-standards.md` is accessible for type hints and docstring enforcement
- `.context/patterns/` is accessible for CQRS, event sourcing, and other patterns
---
## Templates
The bootstrap skill does not use templates. It operates directly on the `.context/` directory structure.
---
## Routing Disambiguation
> When this skill is the wrong choice and what happens if misrouted.
| Condition | Use Instead | Consequence of Misrouting |
|-----------|-------------|--------------------------|
| Task requires research, analysis, or root cause investigation | `/problem-solving` | Bootstrap is a navigation/setup tool; invoking it for analytical tasks wastes context budget loading orientation content with no analytical capability |
| Task requires code generation or implementation | `/problem-solving` (ps-reviewer) or direct coding | Bootstrap agents have no code generation methodology; context loaded with sync/linking logic irrelevant to implementation |
| Task requires architectural design or ADR creation | `/architecture` or `/problem-solving` (ps-architect) | Bootstrap provides no design decision framework; architectural context entirely absent |
| Task requires quality review or adversarial critique | `/adversary` | Bootstrap has no quality scoring or adversarial strategy capability |
| Task requires multi-agent workflow coordination | `/orchestration` | Bootstrap has no orchestration, state tracking, or checkpoint capability |
| Task requires security assessment or threat modeling | `/eng-team` or `/red-team` | Bootstrap has no security methodology; 10+ security agents remain uninvoked |
---
## References
- Bootstrap script: `scripts/bootstrap_context.py`
- Source directory: `.context/rules/`, `.context/patterns/`
- Target directory: `.claude/rules/`, `.claude/patterns/`
- Jerry Constitution: `docs/governance/JERRY_CONSTITUTION.md`
- Platform-specific linking: Windows junction points, Unix/macOS symlinks
---
*Skill Version: 1.0.0*
*Constitutional Compliance: Jerry Constitution v1.0*
*Created: 2026-02-12*
*Last Updated: 2026-02-16*Related Skills
ux-lean-ux
Lean UX hypothesis-driven design sub-skill for the /user-experience parent skill. Facilitates Build-Measure-Learn cycles using Jeff Gothelf and Josh Seiden's Lean UX methodology (3rd ed. 2021). Produces hypothesis backlogs, assumption maps, MVP experiment designs, and validated learning logs. Invoke when teams need hypothesis-driven iteration, assumption mapping, experiment design, or validated learning documentation. Invoked by ux-orchestrator during Wave 2 lifecycle-stage routing or when user intent is "testing hypotheses" during the "During design" stage. Triggers: lean UX, hypothesis, assumption mapping, build-measure-learn, MVP experiment, validated learning, experiment design, hypothesis backlog.
ux-kano-model
Kano model feature classification and prioritization sub-skill for the /user-experience parent skill. Classifies product features into Must-be (M), Performance (O), Attractive (A), Indifferent (I), and Reverse (R) categories using the functional/dysfunctional questionnaire pair methodology (Kano et al., 1984). Computes Customer Satisfaction (CS) coefficients (Better/Worse) for priority matrix visualization. Produces feature classification reports, priority matrices, and survey design templates. Sample size awareness: 5-8 respondents yields directional classification only (MEDIUM confidence); 20+ respondents required for statistical classification (Berger et al., 1993). Invoked by ux-orchestrator during Wave 4 lifecycle-stage routing or when user intent is "Need to prioritize features" at any lifecycle stage. Triggers: Kano, must-be, attractive, one-dimensional, performance feature, satisfaction, feature classification, delighter, feature prioritization, CS coefficient.
ux-jtbd
Jobs-to-Be-Done research and analysis sub-skill for the /user-experience parent skill. Conducts JTBD job statement synthesis, switch interview analysis (Moesta/Spiek four forces), outcome-driven innovation (Ulwick ODI), and job mapping for tiny teams (1-5 people). Invoked by ux-orchestrator when users need to understand user motivations, map jobs to be done, identify switch triggers, or produce job maps with outcome expectations. Sub-skill of /user-experience; routed via ux-orchestrator lifecycle-stage triage. Triggers: JTBD, jobs to be done, switch interview, job mapping, user motivation, outcome, hiring criteria, user jobs, switch forces.
ux-inclusive-design
Inclusive design and WCAG 2.2 accessibility evaluation sub-skill for the /user-experience parent skill. Performs WCAG 2.2 compliance audits across Perceivable, Operable, Understandable, and Robust principles (conformance levels A, AA, AAA) and applies Microsoft Inclusive Design methodology including Persona Spectrum analysis (permanent, temporary, situational disabilities). Produces accessibility audit reports and persona spectrum analyses. Invoke when teams need accessibility compliance evaluation, WCAG conformance auditing, screen reader compatibility assessment, color contrast analysis, cognitive load evaluation, or inclusive design review. Invoked by ux-orchestrator during Wave 3 lifecycle-stage routing or when user intent is "Check accessibility" at any lifecycle stage. Triggers: accessibility, WCAG, ARIA, screen reader, contrast, cognitive load, inclusive, a11y, inclusive design, WCAG 2.2, persona spectrum.
ux-heuristic-eval
Nielsen heuristic evaluation sub-skill for the /user-experience parent skill. Evaluates interfaces against Nielsen's 10 usability heuristics, produces severity-rated findings on a 0-4 scale (Cosmetic to Catastrophic), and generates remediation recommendations with effort estimates. Invoke when teams need structured usability evaluation, interface review, heuristic audit, or severity-rated UX findings. Invoked by ux-orchestrator during Wave 1 lifecycle-stage routing or CRISIS mode triage. Triggers: heuristic evaluation, usability audit, Nielsen heuristics, interface review, severity rating, usability inspection, UX evaluation.
ux-heart-metrics
HEART Metrics framework sub-skill for the /user-experience parent skill. Applies Google's HEART framework (Happiness, Engagement, Adoption, Retention, Task Success) using the Goals-Signals-Metrics (GSM) process to define measurable UX metrics for products and features. Invoked by ux-orchestrator when users need to measure UX health, define UX metrics, establish measurement baselines, or produce dashboard-ready metric specifications. Sub-skill of /user-experience; routed via ux-orchestrator lifecycle-stage triage. Triggers: HEART, metrics, happiness, engagement, adoption, retention, task success, GSM, measurement, UX metrics, dashboard, goals signals metrics.
ux-design-sprint
AJ&Smart Design Sprint 2.0 facilitation sub-skill for the /user-experience parent skill. Facilitates a structured four-day rapid prototyping and validation process compressed from the Google Ventures five-day Design Sprint (Knapp, Zeratsky & Kowitz, 2016; Courtney, 2019). Produces sprint artifacts including challenge maps, solution sketches, storyboards, realistic prototypes, and structured user interview findings with synthesis confidence gates. Invoke when teams need to rapidly validate a product concept, solve a critical design challenge through structured prototyping, test ideas with real users before committing to development, or explore solution directions when they do not know what to build. Triggers: design sprint, GV sprint, rapid prototyping, sprint week, map sketch decide test, 4-day sprint, design sprint 2.0, AJ Smart sprint, validate prototype, test with users, sprint facilitation.
ux-behavior-design
Fogg Behavior Model B=MAP bottleneck diagnosis sub-skill for the /user-experience parent skill. Diagnoses why users fail to take desired actions by analyzing the three B=MAP factors (Motivation, Ability, Prompt) and identifying which factor falls below the action threshold. Produces bottleneck diagnoses, factor-level assessments, and intervention recommendations with synthesis confidence gates. Invoke when teams need to understand why users are not completing a specific action, diagnose behavioral bottlenecks, design behavior change interventions, or analyze post-launch user inaction patterns. Invoked by ux-orchestrator during Wave 4 lifecycle-stage routing or when user intent is "Users not completing action" during the "After launch" stage. Triggers: behavior design, B=MAP, Fogg model, behavior bottleneck, motivation analysis, ability analysis, prompt design, why users don't, user inaction, behavior diagnosis, tiny habits, action threshold.
ux-atomic-design
Atomic Design component taxonomy sub-skill for the /user-experience parent skill. Implements Brad Frost's 5-level component hierarchy (Atoms, Molecules, Organisms, Templates, Pages) for design system architecture. Produces component inventories, design token audits, composition rules, and Storybook coverage reports. Invoke when teams need component taxonomy construction, design system architecture, Storybook integration, design token consistency analysis, or component reuse auditing. Invoked by ux-orchestrator during Wave 3 lifecycle-stage routing or when user intent is "Building component system" during the "During design" stage. Triggers: atomic design, component taxonomy, design tokens, Storybook, atoms molecules organisms, design system, component inventory, component library.
ux-ai-first-design
AI-first interaction design sub-skill (CONDITIONAL) for the /user-experience parent skill. Provides trust-calibrated AI interaction design guidance using Yang et al.'s trust-risk and error-risk classification framework. Produces interaction pattern recommendations, trust calibration assessments, feedback loop designs, and progressive disclosure strategies for AI-powered features. CONDITIONAL: requires WSM >= 7.80 AND enabler research (FEAT-020) complete; otherwise routes to /ux-heuristic-eval with PAIR protocol. Invoke when teams need to design AI-powered interactions, calibrate user trust in AI outputs, classify AI error risks, design human-AI handoff patterns, or audit existing AI interfaces for trust and safety. Triggers: AI-first design, AI interaction, trust calibration, AI UX, conversational UX, AI interface, LLM interface, agentic UX, human-AI interaction, AI transparency, AI error handling, AI onboarding, progressive AI disclosure, trust-risk, error-risk.
user-experience
Parent orchestrator for AI-augmented UX methodology targeting tiny teams (1-5 people). Routes to 10 sub-skills by product lifecycle stage through criteria-gated waves. Invoke when team needs structured UX evaluation, user research, design systems, UX metrics, behavior diagnosis, feature prioritization, design sprints, or AI interaction design. Each sub-skill implements a proven UX framework with synthesis hypothesis confidence gates and MCP design tool integration. Triggers: UX, user experience, usability, heuristic evaluation, JTBD, lean UX, HEART metrics, atomic design, inclusive design, behavior design, Kano model, design sprint, AI-first design, UX audit, accessibility, design system, user research.
use-case
Guided use case authoring and decomposition using Cockburn's 12-step writing process and Jacobson UC 2.0 progressive narrative levels. Creates structured use case artifacts with YAML frontmatter validated against use-case-realization-v1.schema.json. Decomposes use cases into implementation-ready slices with INVEST criteria verification and produces realization interaction sequences for downstream /test-spec and /contract-design consumption. Invoke when writing, creating, authoring, elaborating, slicing, decomposing, or realizing use cases.