ci: add GitHub Actions tests badge + traction launch prep

Author: Joey Ashley

.github/workflows/tests.yml

@@ -0,0 +1,18 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+      - run: pip install -r requirements.txt
+      - run: python -m pytest test/ -q

.planning/traction/01-awesome-claude-code-PR.md

@@ -0,0 +1,57 @@
+# PR: awesome-claude-code
+
+**Target repo**: https://github.com/hesreallyhim/awesome-claude-code
+
+---
+
+## PR Title
+
+```
+Add skill-split: section-level SQLite library for Claude Code skills
+```
+
+---
+
+## PR Body
+
+```
+## What this adds
+
+- [skill-split](https://github.com/JoeyBe1/skill-split) - Section-level SQLite library for Claude Code skills. Search, checkout, and compose any section of any skill/command/plugin with 99% token savings.
+
+## Why it belongs here
+
+skill-split directly enhances Claude Code's skill/command ecosystem by making large skill libraries navigable at the section level. Instead of loading full 21KB files into context, agents can search, retrieve, and compose individual sections (200 bytes each). It handles skills, commands, plugins, hooks, and scripts.
+
+## Category suggestion
+
+Add under the **Tools** or **Utilities** section (or whichever section covers Claude Code developer tooling).
+```
+
+---
+
+## Steps to Submit
+
+1. **Fork the repo**
+   - Go to https://github.com/hesreallyhim/awesome-claude-code
+   - Click **Fork** (top right)
+
+2. **Edit `README.md`**
+   - Find the appropriate section (Tools, Utilities, or Developer Tools)
+   - Add the entry on a new line:
+     ```
+     - [skill-split](https://github.com/JoeyBe1/skill-split) - Section-level SQLite library for Claude Code skills. Search, checkout, and compose any section of any skill/command/plugin with 99% token savings.
+     ```
+
+3. **Commit the change**
+   - Commit message: `Add skill-split: section-level SQLite library`
+
+4. **Open PR**
+   - Base: `hesreallyhim/awesome-claude-code` `main`
+   - Head: your fork
+   - Title: `Add skill-split: section-level SQLite library for Claude Code skills`
+   - Body: paste from above
+
+5. **Check contribution guidelines first**
+   - Some awesome-lists require a specific format or minimum GitHub stars threshold
+   - Check `CONTRIBUTING.md` or `README.md` preamble before submitting

.planning/traction/02-awesome-claude-skills-PR.md

@@ -0,0 +1,58 @@
+# PR: awesome-claude-skills
+
+**Target repo**: https://github.com/travisvn/awesome-claude-skills
+
+---
+
+## PR Title
+
+```
+Add skill-split: section-level SQLite library for Claude Code skills
+```
+
+---
+
+## PR Body
+
+```
+## What this adds
+
+- [skill-split](https://github.com/JoeyBe1/skill-split) - Section-level SQLite library for Claude Code skills. Search, checkout, and compose any section of any skill/command/plugin with 99% token savings.
+
+## Why it belongs here
+
+skill-split is directly relevant to Claude Code skill management. It provides a SQLite-backed library for storing, searching, and deploying skills at the section level — letting you retrieve exactly the section of a skill you need (200 bytes) instead of the full file (21KB+). Supports skills, commands, plugins, hooks, and scripts.
+
+## Category suggestion
+
+Add under the **Tools** section, or whichever category covers skill management utilities.
+```
+
+---
+
+## Steps to Submit
+
+1. **Fork the repo**
+   - Go to https://github.com/travisvn/awesome-claude-skills
+   - Click **Fork** (top right)
+
+2. **Find the right section in `README.md`**
+   - Look for a Tools, Utilities, or Skill Management section
+   - If no clear fit, add under a general **Tools** heading
+
+3. **Add the entry**
+   ```
+   - [skill-split](https://github.com/JoeyBe1/skill-split) - Section-level SQLite library for Claude Code skills. Search, checkout, and compose any section of any skill/command/plugin with 99% token savings.
+   ```
+
+4. **Commit the change**
+   - Commit message: `Add skill-split: section-level SQLite library`
+
+5. **Open PR**
+   - Base: `travisvn/awesome-claude-skills` `main`
+   - Head: your fork
+   - Title: `Add skill-split: section-level SQLite library for Claude Code skills`
+   - Body: paste from above
+
+6. **Check contribution guidelines**
+   - Review `CONTRIBUTING.md` for any format requirements before submitting

.planning/traction/03-reddit-ClaudeAI.md

@@ -0,0 +1,37 @@
+# Reddit Post: r/ClaudeAI
+
+**Subreddit**: r/ClaudeAI
+**URL**: https://www.reddit.com/r/ClaudeAI/
+
+---
+
+## Title
+
+```
+I built a section-level skill library for Claude Code — 99% token savings
+```
+
+---
+
+## Body
+
+```
+If you use Claude Code with a large skill or command library, you've probably run into the context tax: loading a full 21KB skill file to answer one question burns thousands of tokens before you've even started the task. I built skill-split to fix that.
+
+**skill-split** stores every section of every skill, command, plugin, hook, and script in a SQLite database. Search returns individual sections — around 200 bytes each — instead of entire files. That's where the 99% token savings number comes from: you get exactly what you need, nothing more.
+
+The workflow is: search with a keyword or semantic query, get back the matching section ID, check it out to a target directory, and use it. You can also compose new skills by assembling sections from different files. It handles YAML frontmatter, markdown headings, XML tags, Python/JS/TS/shell scripts, and Claude Code-specific formats like plugin.json and hooks.json.
+
+I've ingested 1,365 skill files (19,207 sections) and verified byte-perfect round-trips. Runs fully local with SQLite — no external services required for the core search.
+
+Repo: https://github.com/JoeyBe1/skill-split
+```
+
+---
+
+## Post Notes
+
+- Post as a text post, not a link post (more engagement)
+- Cross-post to r/ClaudeDev if that sub exists
+- Reply to early comments quickly to boost ranking
+- If the post gets traction, pin a comment with the demo GIF link once it's recorded

.planning/traction/04-show-hn.md

@@ -0,0 +1,36 @@
+# Hacker News: Show HN
+
+**URL**: https://news.ycombinator.com/submit
+
+---
+
+## Title
+
+```
+Show HN: Section-level SQLite library for Claude Code skills (99% token savings)
+```
+
+---
+
+## Body
+
+```
+I built skill-split to solve a concrete problem with large Claude Code skill libraries: loading full skill files into context is expensive. A typical skill file runs 15–21KB. Multiply that by a dozen skills and you've burned most of your context window before the task starts.
+
+skill-split parses every section of every skill, command, plugin, hook, and script into a SQLite database. Sections average around 200 bytes. Search returns section IDs; you retrieve exactly what you need. Round-trip is byte-perfect — the original file reconstructs exactly from the stored sections. I've tested this on 1,365 files (19,207 sections) with SHA256 verification.
+
+The stack is intentionally minimal: Python, SQLite with FTS5 for BM25 keyword search, and optional OpenAI embeddings for hybrid semantic search. No server required for the core workflow. Checkout deploys individual sections to their target paths; checkin tracks what's deployed. There's also a compose command to assemble new skills from sections across different source files.
+
+Repo: https://github.com/JoeyBe1/skill-split
+```
+
+---
+
+## Submission Notes
+
+- Show HN posts perform best on weekdays between 9am–12pm Eastern
+- Keep the title under 80 characters (current: 68 chars — good)
+- Do not edit the title after submission (HN penalizes edits)
+- Post the body text as your first comment immediately after submitting
+- Respond to every early comment to drive ranking
+- Do not ask for upvotes

.planning/traction/05-reddit-LocalLLaMA.md

@@ -0,0 +1,42 @@
+# Reddit Post: r/LocalLLaMA
+
+**Subreddit**: r/LocalLLaMA
+**URL**: https://www.reddit.com/r/LocalLLaMA/
+
+---
+
+## Title
+
+```
+Section-level SQLite index for LLM skill libraries — 99% token reduction per query
+```
+
+---
+
+## Body
+
+```
+Context window efficiency is the core constraint on what you can do with a local or API-limited model. I built skill-split to address one specific drain: loading full skill/tool/plugin files into context when you only need one section.
+
+**The problem**: A typical Claude Code skill file is 15–21KB. A library of 50 skills is a megabyte of context you're paying for on every session. Most of that content is irrelevant to the current task.
+
+**The approach**: skill-split parses every section of every file into SQLite (FTS5 with BM25 ranking). A search query returns individual sections averaging ~200 bytes — a 99% reduction vs. loading the full file. You get exactly the relevant section, not the whole document.
+
+The architecture is intentionally offline-first: BM25 keyword search runs fully local with no API calls. If you want semantic search, you can layer in vector embeddings (OpenAI or any compatible endpoint), but the core system requires nothing external. SQLite FTS5 handles multi-word queries with OR logic and supports AND/OR/NEAR boolean operators.
+
+I've validated it against 1,365 files (19,207 sections) with byte-perfect round-trip verification using SHA256. It handles markdown headings, YAML frontmatter, XML tags, Python/JS/TS/shell scripts, and JSON configs — anything structured enough to split into meaningful sections.
+
+Could be adapted for any local LLM skill/tool library beyond Claude Code. The parser and SQLite layer are generic.
+
+Repo: https://github.com/JoeyBe1/skill-split
+```
+
+---
+
+## Post Notes
+
+- r/LocalLLaMA audience cares about: token efficiency, offline-first, concrete benchmarks
+- Lead with the numbers and the local-first angle — this audience is skeptical of cloud dependencies
+- Avoid marketing language; be direct about tradeoffs (e.g., semantic search requires embeddings API)
+- Be ready to discuss the BM25 vs. vector tradeoffs in comments
+- Post as a text post for better ranking in this sub

.planning/traction/06-tweet.md

@@ -0,0 +1,54 @@
+# Tweet Thread: skill-split
+
+**Platform**: X (Twitter)
+**Account**: yours
+**Thread length**: 3 tweets
+
+---
+
+## Tweet 1 (Hook)
+
+```
+Loading full 21KB skill files into Claude Code every session?
+
+I reduced that to ~200 bytes per query.
+
+99% token savings — here's how:
+```
+
+---
+
+## Tweet 2 (What it does)
+
+```
+skill-split stores every section of every skill, command, and plugin in SQLite.
+
+Search returns the exact section you need (not the whole file).
+Check it out. Compose new skills from sections across files.
+
+Works on 19,207 sections across 1,365 files. Byte-perfect round-trip.
+```
+
+---
+
+## Tweet 3 (Link + tags)
+
+```
+Fully local. BM25 keyword search out of the box.
+Optional semantic/hybrid search with embeddings.
+
+github.com/JoeyBe1/skill-split
+
+@AnthropicAI #ClaudeCode #LLM #DeveloperTools
+```
+
+---
+
+## Thread Notes
+
+- Post tweets in rapid succession as a thread (reply to each)
+- Tweet 1 is the hook — do not include the link here
+- The gap between tweet 1 and 2 is intentional: creates a pause before the reveal
+- Consider pinning this thread to your profile after posting
+- If engagement picks up, quote-tweet with the demo GIF once recorded
+- Optimal posting time: Tuesday–Thursday, 9am–11am in your timezone