# I Used Claude Code to Johnny.Decimal-ify 7,500+ Notes
Canonical URL: https://theunclej.com/blog/claude-code-obsidian-jdex
Markdown URL: https://theunclej.com/blog/claude-code-obsidian-jdex.md
Description: kepano solved "how to write." I solved "where to put it." In the AI era, the real challenge isn't capturing knowledge—it's finding it.
Category: AI in Action
Tags: Claude Code, Obsidian, Johnny.Decimal, PKM, AI Workflow
Published: 2026-01-26

---

On January 6th, Obsidian CEO Steph Ango open-sourced [obsidian-skills](https://github.com/kepano/obsidian-skills)—teaching Claude Code how to edit Obsidian's three file formats: Markdown, Bases, and Canvas.

I tried it. Works great. But then I noticed a problem:

**AI knows how to edit files. It doesn't know where files should go.**

It's like hiring a secretary who types 200 WPM but doesn't know your filing system.

So I spent a weekend building a patch: [obsidian-jdex-steward](https://github.com/UncleJ-h/obsidian-jdex-steward).

---

## kepano Solved "How to Write." I Solved "Where to Put It."

kepano's three skills cover Obsidian's file formats:

| Skill    | What It Solves                                     |
| -------- | -------------------------------------------------- |
| Markdown | How to write frontmatter, links, callouts          |
| Bases    | How to build dynamic views (like Notion databases) |
| Canvas   | How to draw knowledge graphs                       |

These are "format capabilities"—AI learned Obsidian's syntax.

But the real challenge in knowledge management isn't format. It's **structure**:

- Which folder should this note go in?
- What other notes is it related to?
- How do I find it among 7,000+ files?

You need an organizational methodology. I chose Johnny.Decimal.

---

## Johnny.Decimal: A Numbering System for Humans and AI

Johnny.Decimal (JD) is a numbering scheme so simple it feels almost dumb:

```
Area (10-19, 20-29, ...)
  └── Category (21, 22, ...)
        └── ID (21.01, 21.02, ...)
```

My vault structure:

- `20-29` = Personal Knowledge
- `26` = Product Philosophy
- `26.01` = "Uncle J's Product Philosophy v3.0"

Why JD? Because it's extremely AI-friendly:

1. **Pure numbers, no ambiguity** — AI doesn't need to interpret "important" or "urgent"
2. **Flat hierarchy** — Three levels max. No getting lost.
3. **Frontmatter-friendly** — One `jd: "26.01"` field. Done.

---

## Real World: 7,526 Files, Starting from 0%

My Obsidian vault has 7,526 Markdown files. 0% had JD numbering.

I ran my scanner:

```bash
python scripts/jdex_scan.py /path/to/vault
```

Output:

```json
{
  "total_markdown": 7526,
  "with_jd": 0,
  "coverage": 0.0
}
```

0%. Expected.

Then I had Claude Code create the JD scaffold:

1. **Global Index** `00.00-JDex.md` — Entry point to the entire vault
2. **System Inbox** `00.01-Inbox.md` — Staging area for new notes
3. **Category Indexes** — One navigation page per category, dynamically generated with Dataview

Next, I added JD frontmatter to 6 core documents in my Product Philosophy folder:

```yaml
---
jd: '26.01'
aliases: [Product Philosophy, Product Philosophy v3]
---
```

Thirty minutes later:

```json
{
  "with_jd": 9,
  "coverage": 0.12
}
```

0.12% looks tiny. But those 9 files are my most-used core documents.

**That's the point of progressive migration: don't aim for 100%. Cover high-frequency files first.**

---

## Design Philosophy: AI Executes, You Architect

My JDex Steward skill follows a few core principles:

**1. Read-Only Scans, Explicit Approval**

The scanner is always read-only. Any file changes require your approval. This isn't a technical limitation—it's a design choice. AI shouldn't reorganize your knowledge system without permission.

**2. Progressive Migration, No Big Surgery**

```
Phase 0: Scan — Look, don't touch
Phase 1: Scaffold — Create skeleton (indexes, templates)
Phase 2: New notes only — New notes get JD, old ones stay
Phase 3: Touch-and-migrate — Migrate old notes when you open them
Phase 4: Weekly cleanup — 15 minutes of maintenance per week
```

The goal isn't 100% coverage. It's "finding things got faster."

**3. Preserve Old Names as Aliases**

When migrating files, old filenames become aliases. Your muscle memory still works. Search doesn't break.

---

## kepano + JDex = Complete AI Knowledge Management Stack

My Claude Code skill combo now looks like this:

| Layer     | Skill                   | Source                         |
| --------- | ----------------------- | ------------------------------ |
| Format    | Markdown, Bases, Canvas | kepano/obsidian-skills         |
| Structure | JDex Steward            | UncleJ-h/obsidian-jdex-steward |

Format layer: "how to write." Structure layer: "where to put it."

Combined, AI can finally work like a real knowledge management assistant:

- "Create a note about MCP protocol" → Uses correct frontmatter format
- "Where should this note go?" → Suggests category and ID based on JD structure
- "Generate an index for Product Philosophy" → Builds it with Dataview queries

---

## Open Source

**JDex Steward**: [github.com/UncleJ-h/obsidian-jdex-steward](https://github.com/UncleJ-h/obsidian-jdex-steward)

MIT license. Use it however you want.

Installation:

```bash
cp -r obsidian-jdex-steward ~/.claude/skills/
```

Then tell Claude Code: "Scan my Obsidian vault for JD coverage."

---

## Final Thoughts

In the AI era, the core challenge of knowledge management isn't "how to capture"—it's "how to find."

kepano's obsidian-skills taught AI Obsidian's syntax. My JDex Steward taught AI an organizational methodology.

Your vault might not need Johnny.Decimal—any system that helps you find things fast is a good system.

But if your vault has grown too large for search to save you, try this combo.