AI-powered skills for PM, Data, QA, Dev workflows. PRD generation, GTM tracking, documentation management, and more.

"Jaan" is a Persian word meaning "soul" or "life." When you say "jaan-e man" — "my soul" — you're expressing the deepest form of care.

Jaan.to means "giving soul to something" — a person, a project, a product. It's the act of breathing life into work that would otherwise feel mechanical.

claude
/plugin marketplace add parhumm/jaan-to
/plugin install jaan-to
/jaan-init

# One-command installer (recommended for end users)
bash <(curl -fsSL https://raw.githubusercontent.com/parhumm/jaan-to/main/scripts/install-codex-skillpack.sh)

# Fallback if you're in this repo locally
bash ./scripts/install-codex-skillpack.sh

Then:

1. Restart Codex.
2. Open your project in Codex.
3. Run /jaan-init once.
4. Use /skills, /jaan-to:*, /jaan-init, or native $skill mentions.

Examples:

/skills
/jaan-init
/jaan-to:pm-prd-write
$pm-prd-write

In Codex, /jaan-to:* and /jaan-init are intentionally preserved as aliases for native $skill.

Development version:

claude
/plugin marketplace add parhumm/jaan-to#dev
/plugin install jaan-to
/jaan-init

Switch stable/dev:

/plugin uninstall jaan-to
/plugin marketplace add parhumm/jaan-to       # stable
/plugin marketplace add parhumm/jaan-to#dev   # dev
/plugin install jaan-to
/jaan-init

Check installed version:

/plugin list

# Claude local dev
claude --plugin-dir /path/to/jaan-to

# Build both runtime targets
./scripts/build-all-targets.sh

# Build Codex skillpack source
bash ./scripts/build-codex-skillpack.sh

# Skillpack drift guard
bash ./scripts/validate-codex-skillpack.sh

# Skill PR prep (regenerate + validate + stage skillpack)
bash ./scripts/prepare-skill-pr.sh

# Integrated dual-runtime smoke
bash scripts/test/e2e-dual-runtime-smoke.sh

./scripts/build-target.sh codex
cd ./dist/jaan-to-codex
./jaan-to setup /path/to/your-project --mode local

setup --mode auto resolves to global if ~/.agents/skills/jaan-to-codex-pack exists, otherwise local.

• Installer auto method SSL failure:
  • Wrapper retries automatically with --method git.
• $skill ambiguity from duplicate names:
  • Remove duplicate project .agents/skills/<jaan-to-skill> entries and use global mode.
• Skills not appearing:
  • Restart Codex after install/reinstall.

Claude Code installation, command namespace (/jaan-to:*), and plugin behavior remain unchanged. Codex support is added as a thin adapter and runner layer without changing Claude runtime contracts.

The bootstrap hook automatically creates jaan-to/ in your project with:

• context/ — Config and boundary templates (customize for your project)
• templates/ — Output templates for each skill
• learn/ — Learning seeds (improve over time)
• outputs/ — Generated outputs (PRDs, tracking code, research, etc.)
• docs/ — Reference docs (style guide, skill spec)

./scripts/verify-install.sh /path/to/your-project

jaan.to follows Claude Code best practices by NOT shipping with configuration files. All settings are OPTIONAL and should be added to YOUR project's .claude/settings.json if needed.

Why? Configuration is project-specific, not plugin-specific. This keeps the plugin portable and ensures you maintain full control over permissions and environment variables in your own codebase.

See Recommended Permissions below for examples of common permission patterns.

Example:

/jaan-to:pm-prd-write "user authentication with OAuth2"

Example:

/jaan-to:data-gtm-datalayer "checkout flow tracking"

Example:

/jaan-to:docs-create "API integration guide"

Examples:

/jaan-to:pm-research-about "React Server Components best practices"
/jaan-to:pm-research-about https://example.com/article

Example:

/jaan-to:learn-add "Always validate email format before API submission"

Example:

/jaan-to:pm-roadmap-add "Implement dark mode toggle"

jaan.to includes specialized agents that enhance skill execution:

jaan.to runs a bootstrap script automatically on your first session. This creates:

• jaan-to/outputs/ directory for generated files
• jaan-to/learn/ directory for accumulated knowledge
• jaan-to/.gitignore to exclude temporary files

Enhance jaan.to's understanding of your project by customizing these files in your project (after installing the plugin):

<!-- jaan-to/context/tech.md -->
## Languages
- Backend: Python 3.11, FastAPI
- Frontend: TypeScript, React 18

## Infrastructure
- Cloud: AWS (ECS, RDS, S3)
- Database: PostgreSQL 15

<!-- jaan-to/context/team.md -->
## Team Size
- 2 engineers, 1 PM, 1 designer

## Sprint Cadence
- 2 weeks, story points, Monday start

<!-- jaan-to/context/integrations.md -->
## Analytics
- Google Analytics 4
- GTM container ID: GTM-XXXXXXX

## Project Management
- Jira workspace: https://company.atlassian.net

Configure permissions in your project's .claude/settings.json:

Best for: Reviewing generated outputs, learning from examples

{
  "permissions": {
    "allow": [
      "Write(jaan-to/**)"
    ],
    "deny": [
      "Bash(*)",
      "Write(src/**)",
      "Write(.env*)"
    ]
  }
}

Best for: Individual contributors generating specs, tracking, documentation

{
  "permissions": {
    "allow": [
      "Write(jaan-to/**)",
      "Bash(npm run *)",
      "Bash(git status)",
      "Bash(git diff *)"
    ],
    "deny": [
      "Write(.env*)",
      "Bash(rm:*)",
      "Bash(curl:*)"
    ]
  }
}

Best for: Team leads, PMs, architects managing documentation and workflows

{
  "permissions": {
    "allow": [
      "Write(jaan-to/**)",
      "Write(docs/**)",
      "Write(jaan-to/outputs/**)",
      "Bash(npm run *)",
      "Bash(git *)"
    ],
    "deny": [
      "Write(.env*)",
      "Bash(rm -rf *)"
    ]
  }
}

All generated files are written to jaan-to/outputs/ in your project directory:

jaan-to/
├── outputs/
│   ├── pm/{slug}/prd.md
│   ├── data/gtm/{slug}/tracking.md
│   └── research/{slug}/report.md
├── learn/
│   └── LEARN.md
└── .gitignore

Recommended .gitignore entry:

jaan-to/outputs/
jaan-to/temp/

jaan.to automatically creates jaan-to/.gitignore with sensible defaults on first run.

If you previously used jaan.to as a standalone .claude/ setup, follow these steps to migrate:

# Remove standalone skill definitions (old naming)
rm -rf .claude/skills/pm-prd-write
rm -rf .claude/skills/data-gtm-datalayer
rm -rf .claude/skills/jaan-skill-create
rm -rf .claude/skills/jaan-skill-update
rm -rf .claude/skills/jaan-docs-create
rm -rf .claude/skills/jaan-docs-update
rm -rf .claude/skills/jaan-learn-add
rm -rf .claude/skills/jaan-research-about
rm -rf .claude/skills/jaan-research-add
rm -rf .claude/skills/jaan-roadmap-add
rm -rf .claude/skills/jaan-pm-roadmap-add

Remove hooks from .claude/settings.json that reference jaan-to/hooks/:

{
  "permissions": {
    "allow": [
      "Read(jaan-to/**)",
      "Read(docs/**)",
      "Write(jaan-to/**)",
      "Glob",
      "Grep"
    ],
    "deny": [
      "Write(src/**)",
      "Write(.env*)",
      "Bash(rm:*)"
    ]
  }
}

Remove the entire "hooks" section — hooks are now managed by the plugin.

If you customized context files in jaan-to/context/, migrate them to jaan-to/context/:

# Create new context directory
mkdir -p jaan-to/context

# Migrate your customizations
cp jaan-to/context/tech.md jaan-to/context/tech.md
cp jaan-to/context/team.md jaan-to/context/team.md
cp jaan-to/context/integrations.md jaan-to/context/integrations.md

# Clean up old structure
rm -rf jaan-to/

Every skill follows a two-phase workflow with human approval:

┌─────────────────────────────────────────────────────────┐
│  PHASE 1: Analysis (Read-Only)                          │
│  - Read context files                                   │
│  - Gather requirements                                  │
│  - Plan structure                                       │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│  HARD STOP: Human Approval                              │
│  "Ready to generate? [y/n]"                             │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│  PHASE 2: Generation (Write)                            │
│  - Generate output                                      │
│  - Quality check (via quality-reviewer agent)           │
│  - Preview                                              │
│  - Write to jaan-to/                                   │
└─────────────────────────────────────────────────────────┘

Why this matters: No accidental writes. You review the plan before anything happens.

Goal: Add OAuth2 authentication to your app

1. Research & PRD
   /jaan-to:pm-research-about "OAuth2 best practices for SaaS"
   /jaan-to:pm-prd-write "OAuth2 authentication with Google and GitHub"

2. User Stories
   /jaan-to:pm-story-write from prd
   → Generates: jaan-to/outputs/pm/stories/01-oauth2-auth/

3. Task Breakdowns
   /jaan-to:frontend-task-breakdown from prd
   → Frontend tasks: Component inventory, state machines, estimates

   /jaan-to:backend-task-breakdown from prd
   → Backend tasks: API endpoints, data models, security

4. QA & Analytics
   /jaan-to:qa-test-cases from prd
   → BDD scenarios with Given/When/Then

   /jaan-to:data-gtm-datalayer "OAuth signup flow tracking"
   → GTM dataLayer pushes for analytics

Flow Diagram:

Research → PRD → Stories → Tasks → QA + Tracking
   ↓         ↓       ↓        ↓         ↓
  Docs    Context  Tickets  Code   Analytics

Goal: Improve homepage based on user behavior

1. Analyze Heatmaps
   /jaan-to:ux-heatmap-analyze "homepage-clicks.csv"
   → Identifies: Low engagement on CTA, high scroll depth

2. Synthesize Research
   /jaan-to:ux-research-synthesize "UX interview transcripts"
   → Themes: Users want clearer value prop

3. Generate Microcopy
   /jaan-to:ux-microcopy-write for homepage CTA
   → 7 languages: English, Spanish, French, German, Arabic, Chinese, Japanese

Goal: Keep docs in sync with code changes

1. Detect Stale Docs
   /jaan-to:docs-update --check-only
   → Reports: 3 stale skill docs, 1 outdated hook doc

2. Fix Automatically
   /jaan-to:docs-update --fix
   → Updates docs based on code changes in last 7 days

3. Add New Documentation
   /jaan-to:docs-create guide "API Integration Tutorial"
   → Creates: docs/guides/api-integration-tutorial.md

┌─────────────┐
│   Initial   │
│   Request   │
└──────┬──────┘
       │
   ┌───▼────────────────────────────────────────────┐
   │ Which workflow?                                │
   ├────────────┬────────────┬──────────────┬───────┤
   │            │            │              │       │
┌──▼──┐   ┌────▼────┐  ┌────▼─────┐  ┌────▼─────┐ │
│ PRD │   │Research │  │  UX Res  │  │   Docs   │ │
└──┬──┘   └────┬────┘  └────┬─────┘  └────┬─────┘ │
   │           │            │              │       │
   ├─Stories   │            │              │       │
   ├─Tasks     └─Learn      └─Microcopy    └─Update│
   ├─Tests                                         │
   └─GTM                                           │
       │                                           │
       └───────────────────────────────────────────┘
                           │
                      ┌────▼─────┐
                      │  Output  │
                      │  Files   │
                      └──────────┘

jaan.to runs entirely on your machine. No telemetry, no analytics, no servers to trust.

Every skill declares exactly which tools it can use. No skill has unrestricted shell access, unrestricted file editing, or access to secret files. Every write-heavy skill follows a HARD STOP pattern — you see a complete preview and approve before anything is written.

Path validation prevents directory traversal: a malicious settings.yaml with paths_outputs: "../../.ssh" is rejected using canonical (realpath) checks. Scripts use set -euo pipefail, temp files use mktemp with cleanup traps, and a PreToolUse security gate blocks dangerous commands (sudo, eval, curl | sh, rm -rf /).

Security standards are enforced automatically. A central validation script (scripts/validate-security.sh) checks skill permissions, shell script safety, hook integrity, and dangerous patterns. It runs on every PR to main, every release preparation, and every issue review — violations block the merge.

See Security Guide for full details on what jaan.to accesses and how privacy sanitization works.

jaan.to actively manages its context window footprint so your AI assistant stays fast and responsive, even with 44+ skills installed.

Result: A typical session with 3 skill invocations saves 5,000-52,000 tokens versus an unoptimized plugin of equivalent capability.

See Token Strategy for the full architecture.

Go from a napkin sketch to a deployed product using jaan.to skill chains.

The Idea to Product Guide walks through the full pipeline — research, PRD, design, code generation, testing, and deployment — with minimum human intervention. Each skill's output feeds the next.

Define → Design → Build → Quality → Ship

jaan.to is open source. To extend:

1. Read Creating Skills
2. Use /jaan-to:skill-create to scaffold a new skill
3. Submit a PR

Claude Code validates plugin.json strictly. Only these fields are allowed: name, version, description, author.

Component paths (skills, agents, hooks, commands) must not be declared — Claude Code auto-discovers them from standard directories.

If you see validation errors during install, check .claude-plugin/plugin.json for extra fields.

If skills don't appear after installing or updating the plugin:

/plugin uninstall jaan-to
/plugin install jaan-to@jaan-to

This reinstalls the plugin and refreshes the registry. You may also need to restart Claude Code (exit and reopen) for changes to take effect.

Ensure the plugin is properly installed:

/plugin list

You should see jaan-to with version 7.x.x. If not, reinstall:

/plugin marketplace add parhumm/jaan-to
/plugin install jaan-to

Proprietary. All rights reserved. See LICENSE for details.

Give soul to your workflow.