100xprism 2.3.1

package/modules/social-content/references/post-templates.md

@@ -0,0 +1,177 @@
+# Post Format Templates
+
+Ready-to-use templates for different platforms and content types.
+
+## Contents
+- LinkedIn Post Templates (The Story Post, The Contrarian Take, The List Post, The How-To)
+- Twitter/X Thread Templates (The Tutorial Thread, The Story Thread, The Breakdown Thread)
+- Instagram Templates (The Carousel Hook, The Reel Script)
+- Hook Formulas (Curiosity Hooks, Story Hooks, Value Hooks, Contrarian Hooks, Social Proof Hooks)
+
+## LinkedIn Post Templates
+
+### The Story Post
+```
+[Hook: Unexpected outcome or lesson]
+
+[Set the scene: When/where this happened]
+
+[The challenge you faced]
+
+[What you tried / what happened]
+
+[The turning point]
+
+[The result]
+
+[The lesson for readers]
+
+[Question to prompt engagement]
+```
+
+### The Contrarian Take
+```
+[Unpopular opinion stated boldly]
+
+Here's why:
+
+[Reason 1]
+[Reason 2]
+[Reason 3]
+
+[What you recommend instead]
+
+[Invite discussion: "Am I wrong?"]
+```
+
+### The List Post
+```
+[X things I learned about [topic] after [credibility builder]:
+
+1. [Point] — [Brief explanation]
+
+2. [Point] — [Brief explanation]
+
+3. [Point] — [Brief explanation]
+
+[Wrap-up insight]
+
+Which resonates most with you?
+```
+
+### The How-To
+```
+How to [achieve outcome] in [timeframe]:
+
+Step 1: [Action]
+↳ [Why this matters]
+
+Step 2: [Action]
+↳ [Key detail]
+
+Step 3: [Action]
+↳ [Common mistake to avoid]
+
+[Result you can expect]
+
+[CTA or question]
+```
+
+---
+
+## Twitter/X Thread Templates
+
+### The Tutorial Thread
+```
+Tweet 1: [Hook + promise of value]
+
+"Here's exactly how to [outcome] (step-by-step):"
+
+Tweet 2-7: [One step per tweet with details]
+
+Final tweet: [Summary + CTA]
+
+"If this was helpful, follow me for more on [topic]"
+```
+
+### The Story Thread
+```
+Tweet 1: [Intriguing hook]
+
+"[Time] ago, [unexpected thing happened]. Here's the full story:"
+
+Tweet 2-6: [Story beats, building tension]
+
+Tweet 7: [Resolution and lesson]
+
+Final tweet: [Takeaway + engagement ask]
+```
+
+### The Breakdown Thread
+```
+Tweet 1: [Company/person] just [did thing].
+
+Here's why it's genius (and what you can learn):
+
+Tweet 2-6: [Analysis points]
+
+Tweet 7: [Your key takeaway]
+
+"[Related insight + follow CTA]"
+```
+
+---
+
+## Instagram Templates
+
+### The Carousel Hook
+```
+[Slide 1: Bold statement or question]
+[Slides 2-9: One point per slide, visual + text]
+[Slide 10: Summary + CTA]
+
+Caption: [Expand on the topic, add context, include CTA]
+```
+
+### The Reel Script
+```
+Hook (0-2 sec): [Pattern interrupt or bold claim]
+Setup (2-5 sec): [Context for the tip]
+Value (5-25 sec): [The actual advice/content]
+CTA (25-30 sec): [Follow, comment, share, link]
+```
+
+---
+
+## Hook Formulas
+
+The first line determines whether anyone reads the rest.
+
+### Curiosity Hooks
+- "I was wrong about [common belief]."
+- "The real reason [outcome] happens isn't what you think."
+- "[Impressive result] — and it only took [surprisingly short time]."
+- "Nobody talks about [insider knowledge]."
+
+### Story Hooks
+- "Last week, [unexpected thing] happened."
+- "I almost [big mistake/failure]."
+- "3 years ago, I [past state]. Today, [current state]."
+- "[Person] told me something I'll never forget."
+
+### Value Hooks
+- "How to [desirable outcome] (without [common pain]):"
+- "[Number] [things] that [outcome]:"
+- "The simplest way to [outcome]:"
+- "Stop [common mistake]. Do this instead:"
+
+### Contrarian Hooks
+- "Unpopular opinion: [bold statement]"
+- "[Common advice] is wrong. Here's why:"
+- "I stopped [common practice] and [positive result]."
+- "Everyone says [X]. The truth is [Y]."
+
+### Social Proof Hooks
+- "We [achieved result] in [timeframe]. Here's the full story:"
+- "[Number] people asked me about [topic]. Here's my answer:"
+- "[Authority figure] taught me [lesson]."

package/modules/social-content/references/reverse-engineering.md

@@ -0,0 +1,195 @@
+# Reverse Engineering Viral Content
+
+Instead of guessing what works, systematically analyze top-performing content in your niche and extract proven patterns.
+
+## Contents
+- The 6-Step Framework (Niche ID, Scrape, Analyze, Playbook, Layer Voice, Convert)
+- The Formula
+- Reverse Engineering Checklist
+
+## The 6-Step Framework
+
+### 1. NICHE ID — Find Top Creators
+
+Identify 10-20 creators in your space who consistently get high engagement:
+
+**Selection criteria:**
+- Posting consistently (3+ times/week)
+- High engagement rate relative to follower count
+- Audience overlap with your target market
+- Mix of established and rising creators
+
+**Where to find them:**
+- LinkedIn: Search by industry keywords, check "People also viewed"
+- Twitter/X: Check who your target audience follows and engages with
+- Use tools like SparkToro, Followerwonk, or manual research
+- Look at who gets featured in industry newsletters
+
+### 2. SCRAPE — Collect Posts at Scale
+
+Gather 500-1000+ posts from your identified creators for analysis:
+
+**Tools:**
+- **Apify** — LinkedIn scraper, Twitter scraper actors
+- **Phantom Buster** — Multi-platform automation
+- **Export tools** — Platform-specific export features
+- **Manual collection** — For smaller datasets, copy/paste into spreadsheet
+
+**Data to collect:**
+- Post text/content
+- Engagement metrics (likes, comments, shares, saves)
+- Post format (text-only, carousel, video, image)
+- Posting time/day
+- Hook/first line
+- CTA used
+- Topic/theme
+
+### 3. ANALYZE — Extract What Actually Works
+
+Sort and analyze the data to find patterns:
+
+**Quantitative analysis:**
+- Rank posts by engagement rate
+- Identify top 10% performers
+- Look for format patterns (do carousels outperform?)
+- Check timing patterns (best days/times)
+- Compare topic performance
+
+**Qualitative analysis:**
+- What hooks do top posts use?
+- How long are high-performing posts?
+- What emotional triggers appear?
+- What formats repeat?
+- What topics consistently perform?
+
+**Questions to answer:**
+- What's the average length of top posts?
+- Which hook types appear most in top 10%?
+- What CTAs drive most comments?
+- What topics get saved/shared most?
+
+### 4. PLAYBOOK — Codify Patterns
+
+Document repeatable patterns you can use:
+
+**Hook patterns to codify:**
+```
+Pattern: "I [unexpected action] and [surprising result]"
+Example: "I stopped posting daily and my engagement doubled"
+Why it works: Curiosity gap + contrarian
+
+Pattern: "[Specific number] [things] that [outcome]:"
+Example: "7 pricing mistakes that cost me $50K:"
+Why it works: Specificity + loss aversion
+
+Pattern: "[Controversial take]"
+Example: "Cold outreach is dead."
+Why it works: Pattern interrupt + invites debate
+```
+
+**Format patterns:**
+- Carousel: Hook slide → Problem → Solution steps → CTA
+- Thread: Hook → Promise → Deliver → Recap → CTA
+- Story post: Hook → Setup → Conflict → Resolution → Lesson
+
+**CTA patterns:**
+- Question: "What would you add?"
+- Agreement: "Agree or disagree?"
+- Share: "Tag someone who needs this"
+- Save: "Save this for later"
+
+### 5. LAYER VOICE — Apply Direct Response Principles
+
+Take proven patterns and make them yours with these voice principles:
+
+**"Smart friend who figured something out"**
+- Write like you're texting advice to a friend
+- Share discoveries, not lectures
+- Use "I found that..." not "You should..."
+- Be helpful, not preachy
+
+**Specific > Vague**
+```
+❌ "I made good revenue"
+✅ "I made $47,329"
+
+❌ "It took a while"
+✅ "It took 47 days"
+
+❌ "A lot of people"
+✅ "2,847 people"
+```
+
+**Short. Breathe. Land.**
+- One idea per sentence
+- Use line breaks liberally
+- Let important points stand alone
+- Create rhythm: short, short, longer explanation
+
+```
+❌ "I spent three years building my business the wrong way before I finally realized that the key to success was focusing on fewer things and doing them exceptionally well."
+
+✅ "I built wrong for 3 years.
+
+Then I figured it out.
+
+Focus on less.
+Do it exceptionally well.
+
+Everything changed."
+```
+
+**Write from emotion**
+- Start with how you felt, not what you did
+- Use emotional words: frustrated, excited, terrified, obsessed
+- Show vulnerability when authentic
+- Connect the feeling to the lesson
+
+```
+❌ "Here's what I learned about pricing"
+
+✅ "I was terrified to raise my prices.
+
+My hands were shaking when I sent the email.
+
+Here's what happened..."
+```
+
+### 6. CONVERT — Turn Attention into Action
+
+Bridge from engagement to business results:
+
+**Soft conversions:**
+- Newsletter signups in bio/comments
+- Free resource offers in follow-up comments
+- DM triggers ("Comment X and I'll send you...")
+- Profile visits → optimized profile with clear CTA
+
+**Direct conversions:**
+- Link in comments (not post body on LinkedIn)
+- Contextual product mentions within valuable content
+- Case study posts that naturally showcase your work
+- "If you want help with this, DM me" (sparingly)
+
+---
+
+## The Formula
+
+```
+1. Find what's already working (don't guess)
+2. Extract the patterns (hooks, formats, CTAs)
+3. Layer your authentic voice on top
+4. Test and iterate based on your own data
+```
+
+## Reverse Engineering Checklist
+
+- [ ] Identified 10-20 top creators in niche
+- [ ] Collected 500+ posts for analysis
+- [ ] Ranked by engagement rate
+- [ ] Documented top 10 hook patterns
+- [ ] Documented top 5 format patterns
+- [ ] Documented top 5 CTA patterns
+- [ ] Created voice guidelines (specificity, brevity, emotion)
+- [ ] Built template library from patterns
+- [ ] Set up tracking for your own content performance

package/modules/spec/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: spec
+description: Write a precise, implementation-ready spec before any code is written. Use when a feature request is vague, ambiguous, or complex — turn fuzzy requirements into an unambiguous spec with acceptance criteria, edge cases, API contracts, and data shapes. Run before /orchestrate or /commit.
+category: engineering
+tier: core
+slash_command: /spec
+allowed-tools: Read Grep Glob Bash(git:*)
+---
+
+# Spec — Implementation-Ready Specification
+
+Turn a vague request into an unambiguous, implementation-ready specification. Do not write any code until the spec is approved.
+
+## How to use
+- `/spec <feature request>` — clarify, read codebase, produce spec, get approval
+
+---
+
+## Phase 1 — Clarify (ask, don't assume)
+
+Ask targeted questions to eliminate ambiguity:
+- **Who** triggers this? (user action, background job, webhook, cron?)
+- **What** is the exact input? (types, shapes, valid ranges, optional vs required)
+- **What** is the exact output? (return value, side effects, UI state change)
+- **What** are the error cases? (invalid input, missing data, network failure, auth failure)
+- **What** are the constraints? (performance, backwards-compatibility, permissions, rate limits)
+- **What** does "done" look like? (how do you know it works?)
+
+Only ask questions that materially change the spec. Infer what you can from the codebase.
+
+---
+
+## Phase 2 — Read context
+
+```bash
+PROJECT_ROOT=$(git rev-parse --show-toplevel)
+cd "$PROJECT_ROOT"
+git log --oneline -10
+```
+
+Read relevant existing code: find related files with Grep/Glob, understand existing data shapes, API contracts, naming conventions. Note anything constraining the implementation.
+
+---
+
+## Phase 3 — Write the spec
+
+```
+## Feature: [name]
+
+### Summary
+One paragraph: what this does and why.
+
+### Inputs
+- [param]: [type] — [description, valid values, required/optional]
+
+### Outputs / Side Effects
+- [what changes, what is returned, what events are fired]
+
+### Acceptance Criteria
+- [ ] [specific, testable condition]
+- [ ] [specific, testable condition]
+
+### Edge Cases & Error Handling
+- [condition] → [expected behavior]
+
+### Out of Scope
+- [explicitly list what this does NOT do]
+
+### Open Questions
+- [anything unresolved — flag for user to decide]
+```
+
+---
+
+## Phase 4 — Get approval
+
+Present the spec. Do **not** proceed to implementation until the user says "approved", "lgtm", "ship it", or similar.
+
+If the user requests changes: update the spec and re-present it.
+
+**Once approved:** run `/commit` or hand off to implementation.

package/modules/subagents/SKILL.md

@@ -0,0 +1,123 @@
+---
+name: subagents
+description: Use subagents to throw more compute at hard problems, keep the main context window clean, and auto-approve safe permissions via hooks. Use when a task is complex, exploratory, or can be parallelized across multiple independent workstreams.
+category: engineering
+tier: on-demand
+allowed-tools: Agent Task Workflow
+---
+
+Invoke this skill when a task is complex, exploratory, or parallel in nature. Subagents keep the main context clean and focused.
+
+## When to Use Subagents
+
+- Append "use subagents" to any request where you want Claude to throw more compute at the problem
+- Use for: codebase exploration, parallel analysis, research, large refactors, test writing
+- Do NOT use for: simple one-file edits, quick lookups, single-step tasks
+
+## Three Subagent Strategies
+
+### A. Parallelization
+Offload independent tasks to separate subagents running simultaneously:
+```
+use 5 subagents to explore the codebase
+→ Explore entry points and startup
+→ Explore React component structure
+→ Explore tools implementation
+→ Explore state management
+→ Explore testing infrastructure
+```
+
+### B. Context Isolation
+Offload heavy research or analysis to a subagent so the main agent's context stays focused on the implementation.
+- Research → subagent → returns a structured result (see *Standard return contract* below)
+- Main agent uses the result, never sees the raw noise
+
+**Reframe for the 1M-context era:** with a 1M-token window, token savings is no longer the
+main reason to isolate. Isolate for **parallelism** (independent work running at once) and
+**adversarial independence** (a fresh subagent with zero authoring context reviews work
+without self-review bias). Treat context savings as a side benefit, not the goal.
+
+### C. Permission Routing via Hook
+Auto-approve obviously-safe tool calls so they don't interrupt with a prompt, while
+anything risky still falls through to human review. 100xprism ships this as a real,
+installable artifact — not just advice:
+
+- **Artifact:** `~/100xprism/hooks/permission-router.py` (a `PreToolUse` Bash hook).
+- **Tier 1 (offline):** a deterministic allowlist auto-approves read-only commands
+  (`ls`, `cat`, `git status`, `grep`, …); destructive/network/credential commands are
+  never auto-approved.
+- **Tier 2 (optional):** set `HOOK_ROUTER_MODEL=claude-haiku-4-5` (needs the `claude`
+  CLI) to route ambiguous commands to a cheap model; only a confident "safe" verdict
+  grants permission, so escalation to a deeper model (e.g. Opus 4.8) or a human is the
+  default for anything uncertain. The router **never blocks** — it only grants.
+- **Enable it:** re-run the installer and turn on the *permission-router* hook (it ships
+  off by default), or run `python3 ~/100xprism/adapters/lib/modules.py emit-hooks` with
+  `HOOK_ROUTER=1`.
+- See `~/100xprism/hooks/README.md` and the hooks docs:
+  <https://docs.claude.com/en/docs/claude-code/hooks>
+
+## Fan-out ladder (how to parallelize)
+
+When a skill says "fan out" or "run these in parallel", pick the highest rung your
+platform supports — they all reach the same outcome, only the determinism differs:
+
+1. **`Workflow` tool (best — Claude Code).** Use it for deterministic, auditable fan-out:
+   one stage per independent unit, structured-output return per agent, a reduce step that
+   aggregates verdicts. Phase order and concurrency caps are enforced by the runtime, not
+   by prose.
+2. **Parallel `Agent`/`Task` subagents (good).** Dispatch the independent units as
+   concurrent subagents in a single message; gather their structured returns and reduce.
+   No runtime enforcement, but real parallelism.
+3. **Serial in-context (fallback — any platform).** If neither tool exists (most
+   non-Claude-Code platforms), run the units one after another in the main context. The
+   outcome is identical; only wall-clock and isolation are lost.
+
+A fan-out site is only worth it when the units are **genuinely independent** (no shared
+mutable state, no ordering dependency). Anything that shares a resource — one Docker DB,
+one build dir — stays serial or needs isolation (worktrees).
+
+## Standard return contract
+
+Exploration / research / review / verdict subagents return a **fixed structure, not
+prose**, so the parent can reduce deterministically (sort by severity, filter by
+confidence, dedup by file):
+
+```json
+{
+  "summary":    "one-line headline of what was found",
+  "findings":   [{ "severity": "critical|high|medium|low", "title": "", "file": "path:line", "detail": "" }],
+  "files":      ["paths touched or inspected"],
+  "risks":      ["what could be wrong / what wasn't covered"],
+  "confidence": "high|medium|low"
+}
+```
+
+Skills adapt the shape to their job (e.g. `gate` subagents return
+`{gate, status, findings[], severity}`), but the principle is constant: **structured in,
+structured out**. With the `Workflow` tool, pass this as the agent's `schema` so the
+return is validated automatically.
+
+**Model routing for fan-out:** route breadth/mechanical scans (file sweeps, lint, simple
+greps) to **Haiku** for cheap concurrency; route depth/judgment (security triage,
+root-cause analysis, go/no-go verdicts) to **Opus** with extended thinking. Default
+cheap, escalate on uncertainty.
+
+## Usage Patterns
+
+```
+# More compute on a hard problem
+"Refactor the auth system. Use subagents."
+
+# Parallel exploration
+"Use 5 subagents to map out every API endpoint and their dependencies"
+
+# Background agent (Claude Code only)
+ctrl+b  →  runs current task in background agent
+```
+
+## Principles
+
+- One focused task per subagent
+- Subagents return summaries, not raw data dumps
+- Use background agents (ctrl+b, Claude Code only) for long-running tasks so you can keep working
+- Subagents are especially valuable for: codebase mapping, test generation, doc writing, and competitive analysis

package/modules/techdebt/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: techdebt
+description: Find and eliminate technical debt — duplicated code, dead code, redundant abstractions. Use at the end of a coding session or when the codebase feels bloated. Scans, reports, and fixes issues with user confirmation.
+category: engineering
+tier: on-demand
+slash_command: /techdebt
+allowed-tools: Bash Read Grep Glob Edit
+model: sonnet
+---
+
+# Techdebt — Technical Debt Scanner
+
+Scan the codebase for technical debt and eliminate it. Run at end of session or when the codebase feels bloated.
+
+## Do NOT ask for permission — scan, report, then ask before fixing.
+
+## How to use
+- `/techdebt` — full scan + report, confirm before fixing
+- `/techdebt fix` — scan and fix without confirmation
+
+---
+
+## Phase 1 — Scan
+
+```bash
+PROJECT_ROOT=$(git rev-parse --show-toplevel)
+cd "$PROJECT_ROOT"
+```
+
+Look for:
+
+1. **Duplicated code** — copy-pasted logic that should be a shared utility
+2. **Dead code** — unused functions, variables, imports, exports, commented-out blocks
+3. **Redundant abstractions** — over-engineered helpers used in only one place
+4. **Inconsistent patterns** — same operation done 3+ different ways across files
+5. **Stale TODOs / FIXMEs** — old comments no longer relevant
+
+Use Grep and Glob to identify candidates. Confirm each item is truly dead/duplicated before reporting.
+
+---
+
+## Phase 2 — Report
+
+```
+## Tech Debt Found
+
+### Duplicated Code
+- `src/utils/formatDate.ts:12` and `src/helpers/dates.ts:45` — identical logic
+  Fix: consolidate into formatDate.ts, delete dates.ts
+
+### Dead Code
+- `src/api/legacyAuth.ts` — no imports found anywhere
+  Fix: delete file
+
+### Stale TODOs
+- `src/components/Modal.tsx:89` — TODO from 6 months ago, feature shipped
+  Fix: remove comment
+```
+
+---
+
+## Phase 3 — Fix (with confirmation)
+
+For each item, ask the user to confirm unless they said "fix". After fixes:
+
+```bash
+# Run tests to verify nothing broke
+npm test 2>&1 | tail -20
+```
+
+**GATE: Tests still pass after cleanup.**

package/modules/terminal-setup/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: terminal-setup
+description: Guide for optimal terminal and environment setup for Claude Code — Ghostty, statusline, tmux worktrees, voice dictation, and tab organization. Use when setting up a new machine or optimizing your Claude Code workflow.
+category: engineering
+tier: on-demand
+allowed-tools: Read
+---
+
+Configure your terminal environment for maximum Claude Code productivity.
+
+## Recommended Setup
+
+### Terminal: Ghostty
+- Synchronized rendering, 24-bit color, proper unicode support
+- Color-code and name terminal tabs for context (e.g., "frontend", "api", "tests")
+- One tab per task or git worktree
+
+### Status Bar: /statusline
+Run `/statusline` to configure your status bar to always show:
+- Current context token usage
+- Current git branch
+- Active task / worktree name
+
+This prevents context overload surprises mid-session.
+
+### Tmux for Parallel Worktrees
+- One tmux window per Claude task/worktree
+- Name windows after the task: `tmux rename-window "auth-refactor"`
+- Lets you switch between parallel Claude sessions without losing context
+
+### Voice Dictation
+- You speak 3x faster than you type
+- Voice-dictated prompts are more detailed and natural → better Claude output
+- macOS: press `fn fn` (double-tap fn key) to activate dictation anywhere
+- Use voice for long context dumps, specs, and bug descriptions
+
+## Quick Setup Checklist
+
+- [ ] Install Ghostty (or iTerm2 with 24-bit color)
+- [ ] Run `/statusline` to enable token + branch display
+- [ ] Set up tmux with one window per active task
+- [ ] Enable macOS voice dictation (`System Settings → Keyboard → Dictation`)
+- [ ] Color-code tabs by domain (frontend=blue, api=green, infra=red)
+
+## Tips
+
+- Before starting a large task: open a new tmux window, name it, start fresh
+- Use `ctrl+b` in tmux to run Claude agents in background
+- The status line's context counter tells you when to `/compact` or start fresh